Linked Lists and other Dynamic Data Structures

Transcription

1 Linked Lists and other Dynamic Data Structures

2 Arrays Fixed in size Allocated in advance within a contiguous memory block Look-up is fast Resizing and Deleting is hard (reallocate and copy)

3 Dynamic Data Structures Grow and shrink one element at a time Not allocated within contiguous memory block Resizing and Deleting is easy Look-up can be hard

4 Linked Lists

5 Linked Lists A linear series of memory locations connected with pointers

6 Linked Lists A linear series of memory locations connected with pointers typedef struct _node { int data; struct node* next; }node; Node Data Pointer to next

7 Linked Lists vs. Arrays Grow and shrink one element at a time No copying or realloc cost on extending Not allocated contiguously in memory Look-up/searching takes linear time, O(n) random accesses

8 More on Implementation

9 More on Implementation Beginning of a linked list Keep track of the head node. End of a linked list tail->next=null;

10 More on Implementation Beginning of a linked list Keep track of the head node. typedef struct _node { int data; struct node* next; struct node* prev; }node; Doubly-linked lists End of a linked list tail->next=null; Node Pointer to prev Data Linked lists can also be doubly-linked and have pointers to next as well as the previous nodes Pointer to next

11 Initializing a List

12 Initializing a List node* head=null; head points to the beginning of the (empty) list

13 Initializing a List node* head=null; head points to the beginning of the (empty) list head=malloc(sizeof(node)); head->data=1; head->next=null; head now contains the first element of the list

14 Initializing a List node* head=null; head points to the beginning of the (empty) list head=malloc(sizeof(node)); head->data=1; head->next=null; head now contains the first element of the list struct list{ node* head; node* tail; //optional }; The list can be represented as a struct of head and tail pointer

15 Adding an Element

16 Adding an Element H

17 Adding an Element Adding to head newnode=malloc(sizeof(node)); newnode->data=1; newnode->next=mylist->head; mylist->head=newnode; H

18 Adding an Element Adding to head H newnode=malloc(sizeof(node)); newnode->data=1; newnode->next=mylist->head; mylist->head=newnode; New

19 Adding an Element Adding to head H newnode=malloc(sizeof(node)); newnode->data=1; newnode->next=mylist->head; mylist->head=newnode; New H New

20 Adding an Element

21 Adding an Element null

22 Adding an Element Adding to tail 1 null node *newnode,*temp; newnode=malloc(sizeof(node)); newnode->data=num; temp=mylist->head; while(temp->next!= NULL) temp=temp->next; temp->next=newnode; newnode->next=null;

23 Adding an Element Adding to tail 1 null node *newnode,*temp; newnode=malloc(sizeof(node)); newnode->data=num; temp=mylist->head; while(temp->next!= NULL) temp=temp->next; New temp->next=newnode; newnode->next=null;

24 Adding an Element Adding to tail 1 null node *newnode,*temp; newnode=malloc(sizeof(node)); newnode->data=num; temp=mylist->head; while(temp->next!= NULL) temp=temp->next; New temp->next=newnode; newnode->next=null; New null

25 Adding an Element Adding to tail 2 // Assuming we have a pointer to tail node* newnode; newnode=malloc(sizeof(node)); node* temp=mylist->tail; temp->next=newnode; newnode->next=null; mylist->tail=newnode;

26 Adding an Element null Adding to tail 2 // Assuming we have a pointer to tail node* newnode; newnode=malloc(sizeof(node)); node* temp=mylist->tail; temp->next=newnode; newnode->next=null; mylist->tail=newnode;

27 Adding an Element null Adding to tail 2 // Assuming we have a pointer to tail node* newnode; newnode=malloc(sizeof(node)); node* temp=mylist->tail; temp->next=newnode; New newnode->next=null; mylist->tail=newnode;

28 Adding an Element null Adding to tail 2 // Assuming we have a pointer to tail node* newnode; newnode=malloc(sizeof(node)); node* temp=mylist->tail; temp->next=newnode; New newnode->next=null; mylist->tail=newnode; New null

29 Adding an Element

30 Adding an Element Left Right

31 Adding an Element Adding in the middle Left Right int i; node* left,right,temp,newnode; newnode=malloc(sizeof(node)); newnode->data=1; temp=mylist->head; for(i=1;i<pos-1;i++) temp=temp->next; left=temp; right=left->next left->next=newnode; newnode->next=right;

32 Adding an Element Adding in the middle Left Right int i; node* left,right,temp,newnode; newnode=malloc(sizeof(node)); newnode->data=1; temp=mylist->head; for(i=1;i<pos-1;i++) temp=temp->next; left=temp; New right=left->next left->next=newnode; newnode->next=right;

33 Adding an Element Adding in the middle Left Right int i; node* left,right,temp,newnode; newnode=malloc(sizeof(node)); newnode->data=1; temp=mylist->head; for(i=1;i<pos-1;i++) temp=temp->next; left=temp; New right=left->next left->next=newnode; newnode->next=right; Left New Right

34 Traversing Linked Lists node* current=mylist->head; while(current!=null){ /*Do Stuff*/ current=current->next; } Node Data Pointer to next

35 Deleting an Element

36 Deleting an Element Left Right del

37 Deleting an Element Left Right del if(to_delete==mylist->head){ mylist->head=to_delete->next; free(to_delete); }else{ left->next=to_delete->next; free(to_delete); }

38 Deleting an Element Left Right del if(to_delete==mylist->head){ mylist->head=to_delete->next; free(to_delete); }else{ left->next=to_delete->next; free(to_delete); } Left del Right

39 Deleting an Element Left Right del if(to_delete==mylist->head){ mylist->head=to_delete->next; free(to_delete); }else{ left->next=to_delete->next; free(to_delete); } Left del Right Left Right

40 Recursive Reverse

41 Recursive Reverse void RecursiveReverse(node** headref) { node* first; node* rest; if (*headref == NULL) return; // empty list base case first = *headref; // suppose first = {1, 2, 3} rest = first->next; // rest = {2, 3} if (rest == NULL) return; // empty rest base case RecursiveReverse(&rest); // Recursively reverse the smaller {2, 3} case first->next->next = first; // put the first elem on the end of the list first->next = NULL; } *headref = rest; // fix the head pointer

42 void RecursiveReverse(node** headref) { node* first; node* rest; if (*headref == NULL) return; first = *headref; rest = first->next; if (rest == NULL) return; RecursiveReverse(&rest); first->next->next = first; first->next = NULL; *headref = rest;}

43 Head void RecursiveReverse(node** headref) { node* first; node* rest; if (*headref == NULL) return; first = *headref; rest = first->next; if (rest == NULL) return; RecursiveReverse(&rest); first->next->next = first; first->next = NULL; rest1 =1 first1 =0 *headref = rest;}

44 Head Head void RecursiveReverse(node** headref) { node* first; node* rest; if (*headref == NULL) return; first = *headref; rest = first->next; if (rest == NULL) return; RecursiveReverse(&rest); first->next->next = first; first->next = NULL; rest2 =2 first2 =1 rest1 =1 first1 =0 *headref = rest;}

45 Head Head Head void RecursiveReverse(node** headref) { node* first; node* rest; if (*headref == NULL) return; first = *headref; rest = first->next; if (rest == NULL) return; RecursiveReverse(&rest); first->next->next = first; first->next = NULL; rest3 =null first3 =2 rest2 =2 first2 =1 rest1 =1 first1 =0 *headref = rest;}

46 Head void RecursiveReverse(node** headref) { node* first; node* rest; if (*headref == NULL) return; first = *headref; rest = first->next; if (rest == NULL) return; RecursiveReverse(&rest); first->next->next = first; first->next = NULL; *headref = rest;} rest3 =null first3 =2 rest2 =2 first2 =1 rest1 =1 first1 =0 Returns

47 Head void RecursiveReverse(node** headref) { node* first; node* rest; if (*headref == NULL) return; first = *headref; rest = first->next; if (rest == NULL) return; RecursiveReverse(&rest); first->next->next = first; first->next = NULL; rest2 =2 first2 =1 rest1 =1 first1 =0 *headref = rest;}

48 Head void RecursiveReverse(node** headref) { node* first; node* rest; if (*headref == NULL) return; first = *headref; rest = first->next; if (rest == NULL) return; RecursiveReverse(&rest); first->next->next = first; first->next = NULL; rest2 =2 first2 =1 rest1 =1 first1 =0 *headref = rest;}

49 Head void RecursiveReverse(node** headref) { node* first; node* rest; if (*headref == NULL) return; first = *headref; rest = first->next; if (rest == NULL) return; RecursiveReverse(&rest); first->next->next = first; first->next = NULL; rest2 =2 first2 =1 rest1 =1 first1 =0 *headref = rest;}

50 Head void RecursiveReverse(node** headref) { node* first; node* rest; if (*headref == NULL) return; first = *headref; rest = first->next; if (rest == NULL) return; RecursiveReverse(&rest); first->next->next = first; first->next = NULL; rest2 =2 first2 =1 rest1 =2 first1 =0 *headref = rest;}

51 Head void RecursiveReverse(node** headref) { node* first; node* rest; if (*headref == NULL) return; first = *headref; rest = first->next; if (rest == NULL) return; RecursiveReverse(&rest); first->next->next = first; first->next = NULL; *headref = rest;} rest2 =2 first2 =1 rest1 =2 first1 =0 Notice rest changes

52 Head void RecursiveReverse(node** headref) { node* first; node* rest; if (*headref == NULL) return; first = *headref; rest = first->next; if (rest == NULL) return; RecursiveReverse(&rest); first->next->next = first; first->next = NULL; rest1 =2 first1 =0 *headref = rest;}

53 Head void RecursiveReverse(node** headref) { node* first; node* rest; if (*headref == NULL) return; first = *headref; rest = first->next; if (rest == NULL) return; RecursiveReverse(&rest); first->next->next = first; first->next = NULL; rest1 =2 first1 =0 *headref = rest;}

54 Head void RecursiveReverse(node** headref) { node* first; node* rest; if (*headref == NULL) return; first = *headref; rest = first->next; if (rest == NULL) return; RecursiveReverse(&rest); first->next->next = first; first->next = NULL; rest1 =2 first1 =0 *headref = rest;}

55 Head void RecursiveReverse(node** headref) { node* first; node* rest; if (*headref == NULL) return; first = *headref; rest = first->next; if (rest == NULL) return; RecursiveReverse(&rest); first->next->next = first; first->next = NULL; rest1 =2 first1 =0 *headref = rest;}

56 Head void RecursiveReverse(node** headref) { node* first; node* rest; if (*headref == NULL) return; first = *headref; rest = first->next; if (rest == NULL) return; RecursiveReverse(&rest); first->next->next = first; first->next = NULL; *headref = rest;}

57 Dos and Don ts

58 Dos and Don ts Don t lose track of the head head=head->next; node* current=head; current=current->next;

59 Dos and Don ts Don t lose track of the head head=head->next; node* current=head; current=current->next; Do check for NULLs current=current->next; while(current!=null) current=current->next;

60 Dos and Don ts Don t lose track of the head head=head->next; node* current=head; current=current->next; Do check for NULLs current=current->next; while(current!=null) current=current->next; Do reassign the tail tail->next=new_node; return; tail->next=new_node; new_node->next=null; return;

61 Dos and Don ts Don t lose track of the head head=head->next; node* current=head; current=current->next; Do check for NULLs current=current->next; while(current!=null) current=current->next; Do reassign the tail tail->next=new_node; return; Do free memory left->next=to_delete->next; return; tail->next=new_node; new_node->next=null; return; left->next=to_delete->next; free(to_delete); return;

62 Other Dynamic DS

63 Other Dynamic DS struct tnode{ int data; struct tnode* left; struct tnode* right; };

64 Other Dynamic DS struct tnode{ int data; struct tnode* left; struct tnode* right; }; struct vertex{ int data; struct edges* edges; };

65 B-Tree Animation BPlusTree.html