Download presentation

Presentation is loading. Please wait.

1
**CSCE 3110 Data Structures & Algorithm Analysis**

Rada Mihalcea 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 [ … + 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
**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

9
Linked Lists bat cat sat vat NULL

10
**Insertion bat cat sat vat NULL mat **

Compare this with the insertion in arrays!

11
Deletion bat cat mat sat 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
**Implementation Declaration**

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

14
**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 \ NULL ptr

15
**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; } 20 NULL ptr

16
**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_FULL(temp)){ fprintf(stderr, “The memory is full\n”); exit (1); }

17
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 temp

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

19
**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 20 NULL 20 NULL

20
**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?

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(?)

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google