LIST PROCESSING

1
Self Referential Structures 1/4
struct node {
A structure of type struct node
int data;
struct node *next; };
data next
struct node a,b;

a b

data next data next

a.data=1; b.data=2;
a.next= b.next=NULL; // a and b do not point to some other node

a b

1 NULL 2 Kumova Metin

Senem NULL 2
Self Referential Structures 2/4
// next is a pointer to a “struct node” object
a.next= &b; // next node for a is b
// as a result b = *(a.next)

1 &b 2 NULL

a b
a.next=&b

*(a.next).data =? a.next->data =?
3
 Self Referential Structures 3/4
struct node { int data; struct node *next; };

struct node * p1 ;
struct node * p2;

// Create objects using pointers, pointers store the address of each object
p1= (struct node *)malloc(sizeof(struct node));
p2= (struct node *)malloc(sizeof(struct node));

p1->data = 4; p1 p2
p2->data= 5;
data=4 // next=p2 data=5 // next=NULL

p1->next= p2; // p2 indicates adress of object

P2->next =NULL;

4
 Self Referential Structures 4/4

struct node * p3= malloc(sizeof(struct node));

p3->data=1;
p3->next=NULL;
p2->next= p3;
p1 p2 p3
data=4 // next=p2 data=5 // next=p3 data=1 // next=NULL

p1->next == p2
p1->next->next == p3

p2->data == p1->next->data
p3->data == p1->next->next->data
5
 Linear Linked Lists
data next data next data next NULL

head head->next

Linear linked list is a data structure of explicit ordering of

items (nodes)

Each item(node) contains two portions:

• information(data) portion
• next address portion

Generally the variable head contains an address or pointer

that gives the location of the first node of the linked list
6
 Linear Linked Lists : Definition
data next data next data next NULL

head head->next

struct node
{ int data; struct node *next; };

// type name for new type is “struct node”

struct node * head; // declares the pointer for first node (head)

7
Linear Linked Lists : 2 nodes in main()
struct node
{ int data; struct node *next; };

main()
{ struct node * head;

/* Create List */
head = (struct node *)malloc(sizeof(struct node));
head
head->data=1; data=1
head->next=NULL; next=NULL

/* Add 1st element */

head->next= (struct node *) malloc(sizeof(struct node));
head->next->data =2;
head->next->next=NULL; head head->next
} data=1 data=2
next=& next=NULL
8
 Linear Linked Lists :
Create and fill 3 nodes in main()
typedef struct node
{ int data; struct node *next; } NODE;

main()
{ NODE * head;
head
head = malloc(sizeof(NODE));
data=1
head->data=1; head->next=NULL; next=NULL

/* Add 1st element */

head->next= malloc(sizeof(NODE)); head head->next
head->next->data =2;
data=1 data=2
head->next->next=NULL;
next=& next=0
/* Add 2nd element */
head->next->next = malloc(sizeof(NODE));
head
head->next->next->data =3;
head->next->next->next=NULL; data=1 data=2 data=2
} next=& next=& next=0
9
 Linked List Types
Single linked lists (next)

Head next Tail next

NULL

Double linked lists (next + previous)

previous previous
Head
next
next next

NULL
Circle linked lists (next)

Head next Tail next

10
Basic Linear Linked List Operations
1. Creating a list
2. Counting elements of list
3. Printing data in list
4. Inserting elements(nodes) to lists
5. Deleting elements(nodes) of list
6. Finding/searching elements in the list
7. Sorting elements
8. etc..
11
 CREATING LINEAR LINKED LIST
An integer array (x[4]) will be used to create a list.

Example 1 : In main() add from head

Example 2 : In main() add from tail
Example 3 : In function ( Using Iteration)
Example 4 : In function ( Using Recursion)
How to call functions in Example 3 and 4

12
 Example 1: In main() add from head
typedef struct node {int data; struct node *next; } NODE;
main(){ int x[4]={1,2,3,4};
NODE * head=NULL; NODE* tmp=NULL;
for (i=0; i<4; i++)
{ if(head==NULL) // FIRST NODE IN LIST
{ head=malloc(sizeof(NODE));
head->data=x[i];
head->next =NULL; }
else { tmp=malloc(sizeof(NODE));
tmp->data=x[i];
tmp->next=head;
head=tmp; }
}
}

Senem Kumova Metin 13

 Example 2 : In main() add from tail
typedef struct node {int data; struct node *next; } NODE;
main()
{ int x[4]={1,2,3,4};
NODE * head=NULL; NODE * tail=NULL;
for (i=0; i<4; i++)
{ if(head==NULL) // FIRST NODE IN LIST
{ head=malloc(sizeof(NODE));
head->data=x[i];
head->next =NULL;
tail=head; }
else { tail->next=malloc(sizeof(NODE));
tail=tail->next;
tail->data=x[i];
tail->next=NULL; } }

Senem Kumova Metin 14

Example 3 : In function ( Using Iteration)
NODE * create_ite (int x[] , int size)
{ NODE * head = NULL; NODE * tail =NULL; int i;
if(size!=0)
{ head = malloc(sizeof(NODE));
head -> data = x[0];
tail = head;
for (i = 1; i<size; ++i)
{ /* add to tail */
tail -> next = malloc(sizeof(NODE));
tail = tail -> next;
tail -> data = x[i]; }
tail -> next = NULL; /* end of list */
}
return head;}

Senem Kumova Metin 15

Example 4 : In function (Using Recursion)

NODE * create _rec(int x[], int size)

{ NODE * head;
if (size==0 ) /* base case */
return NULL;
else { /* method */
head = malloc(sizeof(NODE));
head -> data = x[0];
head -> next = create_rec(x + 1 , size-1);
return head;}
}

16
How to call create functions in Example 3 and 4
typedef struct node
{ int data; struct node *next; } NODE;

NODE * create_ite (int x[] , int size) ; // prototype for iterative function
NODE * create _rec(int x[], int size) ; // prototype for recursive function

main()
{
int x[4]={1,2,3,4};
NODE * head1;
NODE * head2;

head1=create_ite(x,4);
head2=create_rec(x,4); }

17
 Count Elements of a List

Example 1 : Using Iteration

Example 2: Using Recursion
How to call them in main()

18
 Example 1 : Iteration
int count_list_ite (NODE * head)
{ int count=0;
for (; head != NULL; head = head -> next)
++count;
return count; }

Example 2 : Recursion
int count_list_rec (NODE * head)
{ if (head == NULL) return 0;
else return(1 + count_list_rec(head -> next)); }

19
How to call count functions in Example 1 and 2
typedef struct node
{ int data; struct node *next; } NODE;

int count_list_ite (NODE * head); // prototype for iterative function

int count_list_rec (NODE * head); // prototype for recursive function

main()
{
int x[4]={1,2,3,4}; int size1, size2 ;
NODE * head;

head=create(x,4);
size1= count_list_ite(head);
size2= count_list_rec(head); }

20
 Print Elements of a List

Example 1 : Using Iteration

Example 2: Using Recursion

21
 Example 1 : Using Iteration
void print_ite (NODE * head)
{ NODE * p;
if (head == NULL)
printf(“NULL list”);
else { for (p = head; p != NULL; p = p -> next)
printf(“%d\n ”, p -> data); }
}

22
 Example 2 : Using Recursion
void print_rec (NODE * head)
{
if (head == NULL) printf(“NULL list”);
else { printf(“%d\n”, head -> data);
print_rec(head ->next);
}
}

23
 Insertion of Elements in a List
void insert(NODE * p1, NODE * p2, NODE * q)
{ assert (p1-> next == p2);
/* if the expression inside assert is false, the system will print a
message and the program will be aborted */
p1->next = q;
q->next = p2; } initially
p2
C next
p1 A next
NULL
B next
q
24
 How to call insert function
typedef struct node
{ int data; struct node *next; } NODE;
/* Function prototypes */
NODE * create_rec( int x[], int size);
void insert(NODE * p1, NODE * p2, NODE * q)
void print_ite (NODE * head)

main()
{ int x[4]={1,2,3,4};
NODE * head;
NODE n;
n.data=7; n.next=NULL;
head=create(x,4);

insert(head->next,head->next->next, &n);
print_ite(head); }

25
 Delete Elements of a List

Example 1 : Using Iteration

Example 2: Using Recursion

26
 Example 1 : Using Iteration
void delete (NODE * head)
{ NODE * p; NODE * q;
if (head == NULL) printf(“NULL list”);
else { p=head;
while (p != NULL;)
{ q=p;
p = p -> next ;
free(q); } }
}
27
 Example 2 : Using Recursion
void delete (NODE * head)
{
if (head != NULL)
{ delete(head ->next);
free(head);
}
}

28