220 likes | 390 Views
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.
E N D
CSCE 3110Data Structures & Algorithm Analysis RadaMihalcea 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 • 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
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
bat cat sat vat NULL Linked Lists
mat Insertion bat cat sat vat NULL Compare this with the insertion in arrays!
cat sat mat Deletion bat 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)
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
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
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
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)
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
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
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
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?
Other List Operations • swapElements • insertFirst • insertLast • deleteBefore • deleteLast
Running Time Analysis • insertAfter O(?) • deleteAfter O(?) • deleteBefore O(?) • deleteLast O(?) • insertFirst O(?) • insertLast O(?)