Linked Lists ... Node. ptr. cat. hat. vat. fat. bat NULL

Transcription

1 6. Linked List

2 Linked Lists A Linked List consists of many nodes. Each node consists of two parts: LINK and DATA A LINK contains address of (= points to) the next node. Address of nodes is not sequential. ( Address of nodes may change on run time.) Size of a linked list is not predefined. There is a pointer pointing to the first node of a linked list. There is a special address value (= ) at the last node. ptr Node bat cat fat hat... vat

3 Linked Lists Array Sequential representation Insert & Delete : Inefficient due to data shift - O(n) Size of data must be predefined Static storage allocation (during compile time) bat cat fat hat vat Linked List ptr Non-sequential representation Insert & Delete : Efficient due to avoiding data shift - O(1) Size of data needs not to be predefined Dynamic storage allocation (during run time) bat cat fat hat... vat

4 Allocation / Deallocation (Memory) Allocation Get a currently available node. malloc function ex: p =... malloc (sizeof (... )) p A new address is assigned to the pointer variable p! (Memory) Deallocation Return a no longer unused node; free function ex: free(p) p Deallocate the used node!

5 Pointers (Revisited) : Example int i, *pi ; float f, *pf ; i = 1024; f = 3.14; /*static allocation*/ pi = (int *) malloc (sizeof (int)); /*dynamic allocation*/ pf = (float *) malloc (sizeof (float)); /*dynamic alloc.*/ *pi = 1024; *pf = 3.14; printf (*pi,*pf); free (pi); /*dynamic deallocation*/ free (pf); /*dynamic deallocation*/

6 Simple Insertion ptr To Insert eat between cat and fat bat cat fat hat... vat ptr 1 Newly allocate a node by a pointer variable p, and store eat at the node s DATA. 2 Assign the node after cat, which contains fat to the LINK of p. 3 Assign p to the LINK of the node cat. bat cat p 1 3 eat fat 2 hat... vat

7 Simple Deletion ptr To delete fat from the list bat cat fat hat... vat 1 Assign the LINK of fat node to the LINK of cat node 2 Return (deallocate) the fat node by using free ptr 2 free( ) bat cat fat hat... vat 1

8 Node Definition Define the node, named list_node, by using struct Each list_node consist of two fields, DATA and LINK list_ptr is a pointer type pointing to the next list_node ptr is a pointer variable defined on list_ptr, initially typedef struct list_node *list_ptr; typedef struct list_node { int data; list_ptr link; ; list_ptr ptr = ; /*Initialize ptr */ list_prt type ptr (=) DATA field LINK field data link list_node type

9 Basic Operations All the variables p, q, r, are list_ptr type! Initialize Pointer Value : p = p= p->link Move to the next node : p = p -> LINK p Assign Pointer value : Sharing the same node q = p, q = r, p q Compare Pointer Values : only permit ==,!= If (p == q) then, If (p!= q) then, If (p == ) then, If (p!= ) then, If (p -> LINK == ) then.. 9

10 Linked List with Node(s) Linked List with a Single Node ptr = (list_ptr) malloc (sizeof (list_node)); ptr -> data = 10; ptr -> link = ; ptr ptr->data 10 ptr->link Linked List with Two Nodes list_pointer create 2( ) { list_ptr first, second; first = (list_ptr) malloc (sizeof(list_node)); second = (list_ptr) malloc (sizeof (list_node)); second -> link = ; second -> data = 20; first -> data = 10; first -> link = second; return first ; first 10 second 20

11 Insert To do this, three variables are required. ptr : pointing to the first node in a list ins : pointing to the insert position new : pointing to the new node Tow cases are considered. Case 1 : list is empty (i.e., prt is ) Case 2 : list is not empty (i.e., prt is not ) ptr [before] [before] [after] prt ptr = new ptr ins [after] new 25 11

12 Insert addr1 addr2 void Insert (list_ptr *ptr, list_ptr ins) { list_ptr new; new = (list_ptr) malloc (sizeof (list_node)); new -> data = 25; If (*ptr!= ) { new -> link = ins -> link; ins -> link = new; /In case, list is not empty/ else { /In case, list becomes empty/ { new -> link = ; *ptr = new; addrz *ptr addrx ptr To change the ptr value within a function, we need to use pointer!

13 Delete To this end, three variables are also required. ptr : pointing to the first node in a list del : pointing to the delete position pre : pointing to the preceding node w.r.t. the delete node Tow cases exist w.r.t. the delete position Case 1 : the first node in a list (i.e., prev is ) ptr Case 2 : other nodes except the first node (i.e., prt is not ) del pre = ptr delete ptr pre del ptr pre delete 20

14 Delete void Delete (list_ptr *ptr, list_ptr pre, list_ptr del) { If (pre!= ) /In case, the delete node is not the first node/ pre -> link = del -> link; else /In case, the delete node is the first node/ *ptr = (*ptr) -> link; free (del); /Deallocate the delete node/

15 Traverse Print out All Nodes in a List! temp void Traverse-List (list_ptr ptr) { list_ptr temp; temp = ptr while (temp!= ) { printf (temp -> data); temp = temp -> link; ptr D F A... G A D F G What if we use while (temp->link!= )?

16 Linked Stack top Linked Stack / Queue Linked Queue front rear

17 Push : Stack Push (stack_ptr *top, int item) { stack_ptr temp; temp = (stack_ptr)malloc(sizeof (stack)); temp -> data = item; temp -> link = *top; *top = temp; top It does not need stackfull condition! temp item

18 Pop : Stack item=10 top Pop (stack_ptr *top) { stack_ptr temp; int item; temp = *top; If (*top == ) return stack_empty(); item = temp -> data; *top = temp -> link; free(temp); return item; Surely, stack-empty condition is needed. The temp is used for deallocating the delete node; otherwise, numerous garbage are created! temp Free 70

19 Insert : Queue Insert (queue_ptr *front, queue_ptr *rear, int item) { queue_ptr temp; temp = (queue_ptr)malloc(sizeof(queue)); temp -> item = item; temp -> link = ; If (front == ) *front = temp; /Queue Empty/ else *rear -> link = temp; /Queue Not Empty/ *rear = temp; front It does not need Queuefull condition! rear temp item

20 Delete : Queue Delete (queue_ptr *front) { queue_ptr temp; temp = *front; if (*front == ) return queue_empty(); item = temp -> item; *front = temp -> link; free(temp); Clearly, Queue-empty condition is required. The temp is used for deallocating the delete node; otherwise, numerous garbage are created! item=10 front rear temp 10 Free

21 Multiple Stacks Consider Multiple Stacks. (i.e., Num. of stacks n > 1) Method 1: Use of a single Array Method 2: Use of n Arrays Problems: Unpredictable Max. size of each stack! Dynamic change of each stack size! A Not easy to coordinate each stack! Inefficient memory utilization! n-2 n-3 n-2 n-1 Stack 1 Stack 2 Stack k Solution: Use of Linked List! A1 A2 Ak l-1 Stack 1 Stack 2 Stack k

22 Multiple Stacks : Use of Linked List Node Structure for n (>1) Stacks define MAX_SATCKS 10 typedef struct stack *stack_ptr; typedef struct stack { int stack_ptr stack_ptr item; link; top[max_stacks]; Empty Condition for n stacks top[i] == if i-th stack is empty Full Condition for n stacks Not required! (as long as memory is available)

23 Linked Multiple Stacks top[0] Multiple Stacks [Stack 0] D F A... G top[1] [Stack 1] top[n-1] [Stack n-1] B Z C... M P F... K Y Push & Pop take place independently at each stack Each stack size is different from each other, and dynamically varies Memory utilization is very efficient!

24 Polynomial Representation Represent the (Symbolic) Polynomial using Linked List A(x) = a m-1 x e m a 0 x e 0 (where e m-1 > e m-1 >... e 0 >= 0) typedef struct poly_node *poly_ptr; typedef struct poly_node { int coef; int exp; poly_ptr link; poly_ptr a, b, d; poly_node : coef exp link Each term is represented by a node Each node contains a coefficient, an exponent, and a pointer to the next term

25 Polynomial Representation Ex: a = 3x x a b b = 8x 14 3x x

26 Adding Polynomials Consider Two Polynomials as follows: A(x) = a m-1 x e m a 0 x e 0 (pointed by a) B(x) = b n-1 x f n b 0 x f 0 (pointed by b) To Add them, Three Cases must be Considered! Case 1: a->exp == b->exp; add (a->coef + b->coef) a = a->link; b = b->link; Case 2: a->exp < b->exp; b = b->link; Case 3: a->exp > b->exp; a = a->link;

27 CASE 1. a->exp == b->exp Adding Polynomials a [before] a [after] b A(x) = 3 x x x 0 b B(x) = 8 x 14 3 x x 6 result d rear D(x) = 11 x 14

28 CASE 2. a->exp < b->exp Adding Polynomials [before] a a [after] A(x) = 3 x x x 0 b b d B(x) = 8 x 14 3 x x 6 rear d rear D(x) = 11 x 14 3 x 10

29 CASE 3. a->exp > b->exp [before] a Adding Polynomials [after] a A(x) = 3 x x x 0 b b d B(x) = 8 x 14 3 x x 6 rear d rear D(x) = 11 x 14 3 x x 8

30 Case 2! Adding Polynomials When either (a==) or (b==), The comparison terminates! a b b= d rear rear

31 Adding Two Polynomials Adding Polynomials poly_ptr padd( poly_ptr a, ploy_ptr b) { ploy_ptr d, rear; int sum; rear = (poly_ptr) malloc( sizezof(poly_node) ); d = rear; while (a && b) /Until both a & b are not / if ( a->exp < b->exp ) { /Case 2/ attatch (b->coef, b->exp, &rear); b = b->link; else if ( a->exp > b->exp ) { /Case 3/ attach (a->coef, a->exp, &rear); a = a->link; else { /Case 1/ if (sum = a->coef + b->coef) attach(sum, a->exp, &rear) a = a->link; b = b->link;

32 Adding Polynomials poly_ptr padd( poly_ptr a, ploy_ptr b) { /* copy rest of List a and then List b */ for (; a; a = a->link) attach (a->coef, a->exp, &rear); for (; b; b = b->link) attach (b->coef, b->exp, &rear); rear->link = ; temp = d; d = d->link; free (temp); /* delete extra initial node */ return d; void attach(int coefficient, int exponent, poly_ptr *ptr) { poly_ptr temp; temp = (poly_ptr) malloc( sizeof(poly_node) ); temp->coef = coefficient; temp->exp = exponent; (*ptr)->link = temp; /* attach temp to the node pointed by ptr */ *ptr = temp; /* ptr is updated to point to the new node (temp) */

33 Performance Analysis Adding Polynomials m, n : the number of terms in each polynomial A (x) = a m-1 x e m a 0 x e 0 B (x) = b n-1 x f n b 0 x f 0 where e m-1 >... > e 0, f n-1 >... > f 0 Number of Coefficient Additions: O(min{m, n) When none of the exponents is equal 0 When exponents of one polynomial become a subset of exponents of the other min{m, n Number of Exponent Comparisons: O(m+n) When e m-1 > f n-1 > e m-2 > f n-2 >... > e 0 > f 0 m+n-1 Max. number of executions is bounded by m+n O(m+n)

34 What is Garbage? A node that memory has been allocated, but not necessary any more. How to Handle it? Method 1: Return garbage to the storage by calling free(), and reuse it when necessary. Method 2: Connect and manage all garbage in a linked list (called available list) Motivation: Let s do not call unnecessary malloc() and free() functions! Implementation Garbage List Define a pointer variable avail in front of the first node! Define two functions for getting nodes and returning nodes: Get_Node, Return_Node avail List of Available Nodes...

35 Garbage List: Get_Node Take out an available Node from the Available List! poly_ptr Get_Node () { poly_ptr new; /A pointer pointing to a new node/ if (avail!= ) { /If any available node exists/ new = avail; avail = avail -> link; /Take out the first node/ else { /If no available node exists/ new = (poly_ptr) malloc (sizeof (poly_node)); /Request it to the system/ return new; /Return the new node/ avail avail new

36 Garbage List: Return_Node Return an unnecessary node back to the Available List! Return_Node (poly_ptr ptr) { /ptr points to the unnecessary node (i.e., garbage)/ ptr -> link = avail; /Connect the garbage to the available list/ avail = ptr; /Update the avail to point to the first node/ avail ptr avail

37 Ex: e(x) = a(x) * b(x) + d(x) Garbage List! Garbage List: Example poly_ptr a, b, d, e; a = read_poly ( ); b = read_poly ( ); d = read_poly ( ); temp = pmult (a, b); e = padd (temp, d); print_poly (e); a b d temp e The list node temp is not used any more after the addition That is, it produces n (>1) garbage! How to effectively reuse them? 37

38 Garbage List Handling: Method 1 Method 1 Return back n garbage to storage pool by calling free() function! (But, ptr is a pointer that points to the first node of the list) ptr Program Domain... Garbage List free() System Domain Storage Pool 38

39 Garbage List Handling: Method 1 Return_To_System (poly_ptr *ptr) { /ptr points to the first of the garbage list/ poly_ptr temp; while (*ptr!= ) { temp = *ptr; /temp follows up ptr/ *ptr = *ptr -> link; /ptr moves to the next/ free (temp); /return by calling free function/ temp ptr ptr free( ) Return all nodes back to the storage pool by doing a loop from the first to the last in the list Since free() function is called n times, O(n); Inefficient!

40 Garbage List Handling: Method 2 Method 2: Return n garbage to an available list without calling free function (But, ptr is a pointer that points to the first node of the list) ptr Program Domain... Garbage List return avail Program Domain... List of Available Nodes

41 ptr= ptr Return_To_Avail (poly_ptr *ptr, ploy_ptr *avail) { poly_ptr temp; /ptr points to the first of the garbage list/ If (ptr!= ) { temp = *ptr ; while (temp ->link!= ) /until the last node is found/ temp = temp -> link; temp -> link = avail; /connect the garbage list to the avail list/ *avail = *ptr; /let the avail point to the first node again/ *ptr = ; /reinitialize the garbage list by empty/ Garbage List Handling: Method 2 temp avail No free function call is brought forth. But, it needs to find the address of the last node of the list, starting from the first node, O(n); Inefficient!

42 Garbage List Handling: Method 3 Method 3: First, change the Garbage List Structure as follows: The last node points to the first node of the list, i.e., Circular Linked List Second, return the Circular Garbage List to the Singular Available List! ptr avail Program Domain Circular Garbage List return Program Domain Singular List of Available Nodes

43 Garbage List Handling: Method 3 Circular-Return (poly_ptr *ptr, poly_ptr *avail) { poly_ptr temp; if (*ptr!= ) { /if the garbage list is non-empty/ temp = (*ptr) -> link; /temp points to the next node/ (*ptr) -> link = *avail; /connect the first node to the avail list/ *avail = temp; *ptr = ; ptr= ptr /let the avail point to the first node again/ avail temp No need to search for the last node (i.e., )! All nodes are returned at a time. O(1) is guaranteed, regardless of the number of nodes: Efficient!

44 Some Useful Operations Concatenate Two linked lists. Invert a linked list. Find the length of a Circular List. Insert at front and rear.

45 Concatenating Linked Lists Concatenate Tow Listed Lists pointed to by ptr1 and ptr2; prt1 = (a 1, a 2,..., a m ), ptr2 = (b 1, b 2,..., b n ) list_ptr concat (list_ptr ptr1, ptr2) { list_ptr temp; if (ptr1 == ) return ptr2; /if the first list is empty/ else if (ptr2!= ) { temp = ptr1; while (temp -> link!= ) temp = temp -> link; /Move for finding the last node of the first list/ return ptr1; temp -> link = ptr2; /connect the first & second lists/ ptr1 ptr2 temp temp temp

46 Invert Invert a Given list(a 1, a 2,..., a n ) into a new list(a n, a n-1,..., a 1 ) Three Pointer Variables are needed. lead: point to the first of list middle: point to the preceding node of the lead trail: point to the preceding node of the middle before lead a 1 a 2 a... 3 a n-1 a n after middle= lead a 1 trail= middle a 2 trail middle trail middle a... 3 a n-1 middle a n trail middle lead lead lead lead lead=

47 Invert list_ptr Invert (list_ptr lead) { /invert the list pointed to by lead/ list_ptr middle, trail; middle = ; while (lead!= ) { trail = middle; /trail follows up middle/ middle = lead; /middle follows up lead/ lead = lead -> link; /lead moves to the next/ middle -> link = trail; /connect to the preceding node/ return middle;

48 Length of List Count the Number of Nodes in a Circular List int Length (list_ptr ptr) { list_ptr temp; int count = 0; if (ptr!= ) { temp = ptr; do { count++; temp = temp -> link; while (temp!= ptr) return count; ptr count=1 count=2 count=n temp temp temp Since temp==ptr, Stop!

49 Length of List Count the Number of Nodes in a Circular List int Length (list_ptr ptr) { list_ptr temp; int count = 0; if (ptr!= ) { temp = ptr; while (temp!= ptr) {/error! never executed/ return count; count++; temp = temp -> link; ptr count=1 count=2 count=n temp temp temp Since temp==ptr, Stop!

50 Insert : front / rear Insert a Node at the Front and at the Rear. ptr For the Singly Linked List (prt points to the first of list) a 1 a 2 a... 3 a n-1 a n Insert at Front & Insert at Rear: What to do?? Problem?? For the Circular Linked List (prt points to the first of list) ptr a 1 a 2 a... 3 a n-1 a n Insert at Front & Insert at Rear: What to do?? Problem??

51 Insert : front / rear Insert a Node at the Front and at the Rear. Consider Modified Circular Linked List (prt points to the last node of list) Inserting a node at both the Front and the Rear is done with ease. ptr a 1 a 2... a n-1 a n ins a 0 - ptr ins a n+1 - Insert at Front Insert at Rear

52 Insert : front / rear Insert_front_rear (list_ptr *ptr, list_ptr ins) { /ins is the insert node, ptr points to the last node/ if (ptr == ) { /if list is empty/ *ptr = ins; ins -> link = ins; /Circular List of length=1/ else { /list is non-empty/ ins -> link = (*ptr) -> link; (*ptr) -> link = ins; /insert the node/ *ptr = ins; /ptr points to the last node/ What if *ptr=ins is deleted?

53 Doubly Linked Lists Problems of Singly Linked Lists Move to only one way direction (i.e., left to right) Not easy to delete arbitrary nodes (i.e., hard to find the address of previous node; In worst case, O(n)) Solution: Doubly Linked Lists (Circular) linked lists + Double Links = Doubly (Circular) Linked Lists Allow two links for each node; Move to Two way direction; both left and right move ptr LLINK DATA RLINK Previous Node Next Node prt

54 Node Definition typedef struct list_node *list_ptr; typedef struct list_node { list_ptr LLINK; int DATA; list_ptr RLINK; list_ptr ptr = ; /*Initialize ptr */ ptr = (list_ptr) malloc (sizeof (list_node)); Previous Node prt LLINK DATA RLINK Next Node

55 Doubly Linked Lists Basic Structure of Doubly Linked List a 1 a 2 a n Doubly Circular Linked List Transform the basic structure into the circular linked list in order to insert and delete nodes easily Employ an additional dummy node, termed head The data field of head is always empty The head node exists all the times even when list is empty LLINK DATA RLINK Previous Node Next Node head

56 Doubly Circular Linked Lists Doubly Circular Linked Lists It starts from the head, and the last & the first nodes point to the head RLINK and LLINK of head point to the first and the last nodes, respectively. If ptr points to an arbitrary node, we have the following rules: ptr -> LLINK -> RRLINK = ptr = ptr -> RLINK -> LLINK LLINK head RLINK a 1 a 2 a n a 3 ptr

57 Examples Doubly Circular Linked Lists LLINK RLINK head a 1 a 2 a n a 3 Case I. List consists of n (n > 1) nodes.. a 1 LLINK. -. head RLINK LLINK. -. head RLINK Case II. Single node list (i.e., n=1) Case III. Empty list (i.e., n=0)

58 Insert Two Pointer Variables are required. ins : it points to the insert position new : it points to the newly allocated node Insert (node_ptr ins, node_ptr new) { new -> LLINK = ins; new -> RLINK = ins -> RLINK; ins -> RLINK -> LLINK = new; ins -> RLINK = new; new a 1 before ins after I. Empty Case LLINK LLINK head RLINK head RLINK ins

59 II. Non-Empty Case before Insert LLINK. -. head RLINK.. a 1 a 2 a n a 3 after ins LLINK. -. head RLINK. a 1 a 2 a 3 a n. 4 ins a 1. new

60 Delete Two Pointer Variables are also required! Delete (node_ptr head, node_ptr del) { head: it points to the first node of the list del: it points to the delete node Different from Singly lists, it does not need to know the preceding node if (del == head) printf ( Do not delete ) /if list is empty; i.e., only head node/ else { del -> LLINK -> RLINK = del -> RLINK; del -> RLINK -> LLINK = del -> LLINK; free (del); del I. Single Node Case before after 2 LLINK LLINK a head RLINK head RLINK 1

61 II. Multiple Node Case before Delete LLINK. -. head RLINK.. a 1 a 2 a n a 3 after del LLINK. -. head RLINK 1.. a 1 a 2 a n 2 del free( ) 3 a 3