Iterate through a List and print items - c

Question

I have a list like this
#include <stdio.h>
#include <stdlib.h>
struct ListItem
{
int x;
int y;
struct ListItem *next;
};
int main()
{
int x1 =0;
int y1 = 0;
printf("Please enter the x coordinate: ");
scanf("%d", &x1);
printf("Please enter the y coordinate: ");
scanf("%d", &y1);
struct ListItem root;
if( root.next == NULL )
{
root.x = x1;
root.y = y1;
//I dont know what should I assign here but I want to have about 30 locations
//root.next = struct ListItem next;
}
//WHAT SHOULD I DO HERE?
{
printf("Your location is : (%d,%d)\n", root.x, root.y);
}
}
Now I want to write a loop to iterate through it so that I can print every element on the list :)
Basically what I am trying to do is, I want to get the locations from the user and then I will print them.
Please help .

Answer 1

Linked list. Input coordinates until you enter zero.
#include <stdio.h>
#include <stdlib.h>
struct ListItem
{
int x;
int y;
struct ListItem *next;
};
int main()
{
int x1 =0;
int y1 = 0;
int iCount = 0; // keep count of the structures allocated
int iEach = 0;
struct ListItem root = { 0, 0, NULL};// declare and initialize the first structure
struct ListItem* pFreeListItem = NULL;// declare a pointer and initialize it null. use for freeing memory later
struct ListItem* pListItem = &root;// declare a pointer and initialize it to point to the first structure
while ( 1) { // the main loop
printf("Please enter the x coordinate: ");
scanf(" %d", &x1);
printf("Please enter the y coordinate: ");
scanf(" %d", &y1);
pListItem->x = x1; // use the pointer to assign the coordinate
pListItem->y = y1;
iCount++; // keep track of the number of structures
printf("Input complete for location number %d\n", iCount);
printf("Enter 0 to exit or any other number to continue: ");
scanf(" %d", &y1);
if ( y1 == 0) { // exit the loop if zero is entered
break;
}
else { // if zero was not entered
pListItem->next = malloc ( sizeof ( struct ListItem));// allocate memory for the next structure
if ( pListItem->next == NULL) {
//allocation failed
exit (1);
}
pListItem = pListItem->next; // set the pointer to point to the new 'next' structure
pListItem->next = NULL; // set this to null as no memory has yet been allocated
}
}
pListItem = &root; // set the pointer to the original structure root
for ( iEach = 0; iEach < iCount; iEach++) // loop through each structure. icount holds the number of structures
{
printf("Location number %d is : (%d,%d)\n", iEach + 1, pListItem->x, pListItem->y);
pListItem = pListItem->next; // set the pointer to the next structure
}
pListItem = root.next; // set the pointer to the first allocated structure
for ( iEach = 1; iEach < iCount; iEach++) // loop through each structure
//start with 1 as the first structure was not allocate and does not need to be freed. icount holds the number of structures
{
pFreeListItem = pListItem->next; // set the free pointer to the next structure
free ( pListItem); // free the memory for the structure
pListItem = pFreeListItem; // point to the free pointer
}
}
EDIT: this code will show the address of the pointers and maybe that will help clarify what is going on
else { // if zero was not entered
pListItem->next = malloc ( sizeof ( struct ListItem));// allocate memory for the next structure
if ( pListItem->next == NULL) {
//allocation failed
exit (1);
}
printf ( "pListItem points to %p and pListItem->next points to %p\n", pListItem, pListItem->next);
pListItem = pListItem->next; // set the pointer to point to the new 'next' structure
pListItem->next = NULL; // set this to null as no memory has yet been allocated
printf ( "NOW pListItem points to %p and pListItem->next points to %p\n", pListItem, pListItem->next);
}

Answer 2

Here's a toy program that works, demonstrating a list stored in an array.
Actually compiles with no warnings - gcc -Wall -Werror -std=c99 l.c
The dynamically allocated version using calloc, works to, if you want dynamic memory, so you can add to the list later.
ladm#ash:~/src/scratch> ./a.out|head | sed 's/^/ /'
array[ 0] : (1,1)
array[ 1] : (2,2)
array[ 2] : (3,3)
Your location is : (3,3)
Your location is : (2,2)
Your location is : (1,1)
array[ 2] : (3,3)
array[ 1] : (2,2)
array[ 0] : (1,1)
ladm#ash:~/src/scratch> cat l.c | sed 's/^/ /'
#include <stdio.h>
#include <assert.h>
typedef struct ListItem
{
int x;
int y;
struct ListItem *next;
} ListItem;
void getCoord(int *x, int *y) {
static int num = 1;
*x = *y = num++;
}
int main( int argc, char **argv) {
const int N = 3;
ListItem listN[ N];
/* ListItem *listN = calloc( N, sizeof( ListItem)); */ /* Dynamic allocation method */
/* First Coordinate */
listN[ 0].next = NULL; /* Add item at front of list */
getCoord( &listN[ 0].x, &listN[ 0].y); /* Does the scanf stuff */
/* Add new coords to the list */
for (int i=1; i < N; i++) {
getCoord( &listN[ i].x, &listN[ i].y); /* Does the scanf stuff */
listN[ i].next = &listN[ i-1]; /* Add item at front of list */
}
/* List built */
{
ListItem *first = &listN[ N-1];
/* Dump all the coords in backing store */
for (int i = 0; i < N; i++) {
printf("array[ %d] : (%d,%d)\n", i, listN[ i].x, listN[ i].y);
}
/* Print list following pointers - should be reversed */
for (ListItem *l = first; l != NULL; l = l->next) {
printf("Your location is : (%d,%d)\n", l->x, l->y);
}
/* Dump all the coords in backing store reversed */
for (int i = N-1; i >= 0; --i) {
printf("array[ %d] : (%d,%d)\n", i, listN[ i].x, listN[ i].y);
}
}
}

Answer 3

If you know the number of locations you will have, you better use an array or matrix, like:
int x[30];
int y[30];
or
int location[60];
or
int location[2][30];
And use a for loop to iterate over the elements.
If you don't know the number of locations, then you wish to search for LinkedList (or ArrayList) implementation in C. There are plenty of material on Internet teaching how to use those data structures.

Answer 4

A good way to iterate through a list would be making functions like give_successor and is_after_last, then using it in a for loop, like that:
struct ListItem *l;
struct ListItem *head;
for (l = head; !(is_after_last(l)); l = give_successor(l)) {
do_stuff(l);
}
Implementation of is_after_last may vary depending on implementation of the list: you might want to check if l == NULL or if l points to artificial element at the end of the list.
Function give_successor looks like that:
struct ListItem *give_successor(l) {
if (l == NULL)
return NULL;
return l->next
}
However, I recommend using tables and libraries like those.