LIST PROCESSING.

Presentation on theme: "LIST PROCESSING."— Presentation transcript:

LIST PROCESSING

Self Referential Structures 1/4
struct node { int data; struct node *next; }; struct node a,b; a b a.data=1; b.data=2; a.next= b.next=NULL; // a and b do not point to some other node A structure of type struct node data next data next data next 1 NULL 2 NULL Senem Kumova Metin

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) a b *(a.next).data =? a.next->data =? 1 &b 2 NULL a.next=&b

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; p2->data= 5; p1->next= p2; // p2 indicates adress of object P2->next =NULL; data=5 // next=NULL data=4 // next=p2 p1 p2

Self Referential Structures 4/4
struct node * p3= malloc(sizeof(struct node)); p3->data=1; p3->next=NULL; p2->next= p3; p1->next == p2 p1->next->next == p3 p2->data == p1->next->data p3->data == p1->next->next->data data=5 // next=p3 data=4 // next=p2 p1 p p3 data=1 // next=NULL

NULL data 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

next NULL data 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)

Linear Linked Lists : 2 nodes in main()

Linear Linked Lists : Create and fill 3 nodes in main()

Creating a list Counting elements of list Printing data in list Inserting elements(nodes) to lists Deleting elements(nodes) of list Finding/searching elements in the list Sorting elements etc..

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

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

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

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

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; } }

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); }

Count Elements of a List
Example 1 : Using Iteration Example 2: Using Recursion How to call them in main()

Example 1 : Iteration Example 2 : Recursion
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)); }

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); }

Print Elements of a List
Example 1 : Using Iteration Example 2: Using Recursion

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); } }

Example 2 : Using Recursion

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 p1 A next C next NULL q B next

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); }

Delete Elements of a List
Example 1 : Using Iteration Example 2: Using Recursion

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); } } }

Example 2 : Using Recursion