CSCE 3110 Data Structures & Algorithm Analysis Growable Arrays. Lists. Reading: Chap. 3 Weiss

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

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

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)

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

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?

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

Using Dynamically Allocated Memory (review) 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); request memory return memory

Linked Lists bat  cat  sat  vat NULL

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

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

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)

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

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

Example: Create a two-nodes list 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; } 10  20 NULL ptr

Insert (after a specific position) 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_EMPTY(temp)){ fprintf(stderr, “The memory is full\n”); exit (1); }

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

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

void removeAfter(pnode node) { / 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 10  50  20 NULL 10  20 NULL

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

Other List Operations swapElements insertFirst insertLast deleteBefore deleteLast

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