1 / 28

LIST PROCESSING

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 b . A structure of type struct node. data. next.

buzz
Download Presentation

LIST PROCESSING

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. LIST PROCESSING

  2. 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 b A structure of type struct node data next data next data next 1 NULL 2 NULL Senem Kumova Metin

  3. 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

  4. p1 p2 data=4 // next=p2 data=5 // next=NULL 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;

  5. p1 p2 p3 data=1 // next=NULL data=4 // next=p2 data=5 // next=p3 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

  6. data next data next data next NULL Linear Linked Lists head head->next • Linear linked list is a data structure of explicit ordering of items (nodes) • Each item(node) contains twoportions: • 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

  7. data next data next data next NULL Linear Linked Lists : Definition 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)

  8. head data=1 next=NULL head head->next data=1 next=& data=2 next=NULL 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->data=1; head->next=NULL; /* Add 1st element */ head->next= (struct node *)malloc(sizeof(struct node)); head->next->data =2; head->next->next=NULL; }

  9. head data=1 next=NULL head head->next data=1 next=& data=2 next=0 Linear Linked Lists : Create and fill 3 nodes in main() typedef struct node { int data; struct node *next; } NODE; main() { NODE * head; head = malloc(sizeof(NODE)); head->data=1; head->next=NULL; /* Add 1st element */ head->next= malloc(sizeof(NODE)); head->next->data =2; head->next->next=NULL; /* Add 2nd element */ head->next->next = malloc(sizeof(NODE)); head->next->next->data =3; head->next->next->next=NULL; } head data=1 next=& data=2 next=& data=2 next=0

  10. Head Head Tail Tail next next next previous Head previous NULL next next next Linked List Types Single linked lists (next) next Double linked lists (next + previous) NULL Circle linked lists (next)

  11. Basic Linear Linked List Operations • 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..

  12. 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

  13. 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

  14. 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

  15. 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

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

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

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

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

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

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

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

  23. 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); • } • }

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

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

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

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

  28. Example 2 : Using Recursion void delete (NODE * head) { if (head != NULL) { delete(head ->next); free(head); } }

More Related