1 / 22

CSCE 3110 Data Structures & Algorithm Analysis

CSCE 3110 Data Structures & Algorithm Analysis. Rada Mihalcea http://www.cs.unt.edu/~rada/CSCE3110 Growable Arrays. Lists. Reading: Chap. 3 Weiss. Linked Lists. Avoid the drawbacks of fixed size arrays with Growable arrays Linked lists. Growable arrays.

luz
Download Presentation

CSCE 3110 Data Structures & Algorithm Analysis

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. CSCE 3110Data Structures & Algorithm Analysis RadaMihalcea http://www.cs.unt.edu/~rada/CSCE3110 Growable Arrays. Lists. Reading: Chap. 3 Weiss

  2. Linked Lists • Avoid the drawbacks of fixed size arrays with • Growable arrays • Linked lists

  3. Growable arrays • Avoid the problem of fixed-size arrays • Increase the size of the array when needed (I.e. when capacity is exceeded) • Two strategies: • tight strategy (add a constant): f(N) = N + c • growth strategy (double up): f(N) = 2N

  4. Tight Strategy • Add a number k (k = constant) of elements every time the capacity is exceeded 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 C0 + (C0+k) + … (C0+Sk) = S = (N – C0) / k Running time? C0 * S + S*(S+1) / 2  O(N2)

  5. Tight Strategy void insertLast(int rear, element o) { if ( size == rear) { capacity += k; element* B = new element[capacity]; for(int i=0; i<size; i++) { B[i] = A[i]; } A = B; } A[rear] = o; rear++; size++; }

  6. Growth Strategy • Double the size of the array every time is needed (I.e. capacity exceeded) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 C0 + (C0 * 2) + (C0*4) + … + (C0*2i) = i = log (N / C0) Running time? C0 [1 + 2 + … + 2 log(N/C0) ]  O(N) How does the previous code change?

  7. Linked Lists • Avoid the drawbacks of fixed size arrays with • Growable arrays • Linked lists

  8. int i, *pi; float f, *pf; pi = (int *) malloc(sizeof(int)); pf = (float *) malloc (sizeof(float)); *pi =1024; *pf =3.14; printf(”an integer = %d, a float = %f\n”, *pi, *pf); free(pi); free(pf); Using Dynamically Allocated Memory (review) request memory return memory

  9. bat  cat  sat  vat NULL Linked Lists

  10. mat  Insertion bat  cat  sat  vat NULL Compare this with the insertion in arrays!

  11. cat  sat  mat  Deletion bat  vat NULL dangling reference

  12. List ADT • ADT with position-based methods • generic methods size(), isEmpty() • query methods isFirst(p), isLast(p) • accessor methods first(), last() before(p), after(p) • update methods swapElements(p,q), replaceElement(p,e) insertFirst(e), insertLast(e) insertBefore(p,e), insertAfter(p,e) removeAfter(p)

  13. typedef struct node, *pnode;typedef struct node { char data [4]; pnode next; };Creationpnode ptr =NULL; Testing#define IS_EMPTY(ptr) (!(ptr))Allocationptr=(pnode) malloc (sizeof(node)); Implementation Declaration

  14. Create one Node e  name  (*e).name strcpy(ptr  data, “bat”); ptr  link = NULL; address of first node ptr link ptr data  b a t \0 NULL ptr

  15. ptr 10  20 NULL pnode create2( ){/* create a linked list with two nodes */ pnode first, second; first = (pnode) malloc(sizeof(node)); second = ( pnode) malloc(sizeof(node)); second -> next= NULL; second -> data = 20; first -> data = 10; first ->next= second; return first;} Example: Create a two-nodes list

  16. void insertAfter(pnode node, char* data){/* insert a new node with data into the list ptr after node */ pnode temp; temp = (pnode) malloc(sizeof(node)); if (IS_FULL(temp)){ fprintf(stderr, “The memory is full\n”); exit (1); } Insert (after a specific position)

  17. 10  strcpy(temp->data, data); if (node) { noempty list temp->next=node->next;node->next= temp; } else { empty list temp->next= NULL; node =temp; }} node 20 NULL 50  temp

  18. 10  20 NULL 50  20 NULL 50  10  20 NULL 50  20 NULL 10  Deletion node trail = NULL node (a) before deletion (b)after deletion Delete node other than the first node head node head

  19. 10  20 NULL 50  20 NULL 10  void removeAfter(pnode node){/* delete what follows after node in the list */ pnode tmp; if (node) { tmp = node -> next; node->next = node->next->next; free(tmp); }} node

  20. void traverseList(pnode ptr){ printf(“The list contains: “); for ( ; ptr; ptr = ptr->next) printf(“%4d”, ptr->data); printf(“\n”); } Traverse a list Where does ptr point after this function call?

  21. Other List Operations • swapElements • insertFirst • insertLast • deleteBefore • deleteLast

  22. Running Time Analysis • insertAfter O(?) • deleteAfter O(?) • deleteBefore O(?) • deleteLast O(?) • insertFirst O(?) • insertLast O(?)

More Related