Linear Data Structure Linked List

Size: px

Start display at page:

Download "Linear Data Structure Linked List"

Carmel Wood
6 years ago
Views:

1 . Definition. Reresenting List in C. Imlementing the oerations a. Inserting a node b. Deleting a node c. List Traversal. Linked imlementation of Stack 5. Linked imlementation of Queue 6. Circular List a. Circular Stack b. Circular Queue 7. Doubly Linked List 8. Circular Doubly Linked List Linear Data Structure Linked List Introduction of Linked List What are the drawbacks of using sequential storage to reresent stacks and queues? One major drawback is that a fixed amount of storage remains allocated to the stack or queue even when the structure is actually using a smaller amount or ossibly no storage may be allocated, thus introducing the ossibility of overflow. Definition [ Linked List ] Linear linked list is a data structure of exlicit ordering of items and each item contains two ortions; one is information ortion and the other one is next address ortion. In exlicit ordering of items, each item contained within itself the address of another item. Such an exlicit ordering gives rise to a data structure which is known as a linear linked list. list null Figure : Linear Linked List Each item in a list is called a node and contains two fields, an information field and a next address field. The information field holds the actual element on the list. The next address field contains the address of the next node in the list. Such an address, which is used to access a articular node, is known as a ointer. The entire linked list is accessed from an external ointer list that oints to first node in the list. The next address field of the last node in the list contains a secial value called null value. Reresenting List in C The following C code reresents the List. tyedef struct int info; // information ortion struct Node *next; // next address ortion Node; Page of 8

2 tyedef Node *Nodetr; Imlementing the oerations Imlementing various oerations like insert, remove, and list_traversal. Nodetr getnode() return ( (Nodetr) malloc (sizeof(node)) ); void insert(nodetr List, int value) Nodetr = getnode(); ->info = value; ->next = List; List = ; int remove(nodetr List) int x; Nodetr = List; List = ->next; x = ->info; free(); return x; void list_traversal(nodetr List) Nodetr = List; for(;!=null;) int x = ->info; rintf( %d, x); = ->next; Note: Do not use the exact codes; you have to modify these codes to use in any rogram that imlements Linked List. Linked Imlementation of Stack struct node int info; node *next; ; tyedef struct node *Nodetr; int isemty(nodetr &list) if(list == NULL) return ; else return 0; void ush(nodetr &list, int value) Node ; = (Nodetr)malloc(sizeof(node)); if(==null) rintf("can't allocate memory."); Page of 8

3 getch(); exit(0); ->next = list; list = ; list->info = value; int o(nodetr &list) int info; if(isemty(list)) rintf("underflow"); getch(); exit(0); Nodetr ; = list; info = ->info; list = ->next; free(); return info; Linked Imlementation of Queue struct Node int info; struct Node *next; ; tyedef struct Node* nodetr; int isemty(nodetr& front) if(front==null) return ; else return 0; void insert(nodetr& front, nodetr& rear, int v) nodetr = (nodetr)malloc(sizeof(node)); ->next = NULL; ->info = v; if(front==null) front = ; if(rear == NULL) rear = ; else rear->next = ; rear = rear->next; int remove(nodetr &front) if(isemty(front)) Page of 8

4 rintf("underflow"); getch(); exit(); nodetr ; = front; int x = ->info; front = ->next; free(); return x; Circular Linked List Although a linear linked list is a useful data structure, it has several shortcomings. Given a ointer to a node in a linear list, we cannot reach any of the nodes that recede node. If a list is traversed the external dummy ointer to the list must be reserved to be able to reference the list again. Suose that a small change is made to the structure of a linear list, so that the next field in the last node contains a ointer back to the first node rather than the null ointer. Such a list is called a Circular Linked List. list Figure : Circular Linked List A Circular List is a linked list in which the node at the last of the list, instead of having a null ointer, oints back to the node at the head of the list. We then need only one ointer (dummy) to access both ends of the list, since we know that last->next oints back to the first node in the list. Stack as a Circular List int isemty(nodetr &stack) if(stack == NULL) return ; else return 0; void ush(nodetr &stack, int x) Nodetr = (Node)malloc(sizeof(Node)); ->info = x; if(stack==null) stack = ; else ->next = stack->next; stack->next = ; Page of 8

5 The following diagram illustrates the sequences of ush oeration. stack x Figure : Sequences of ush oeration. int o(nodetr &stack) int info; Nodetr ; if(stack == null) rintf("underflow"); getch(); exit(0); = stack->next; info = ->info; if(==stack) // in case of one node only. stack = null; else stack->next = ->next; free(); return info; The following diagram illustrates the sequences of o oeration. stack x free Figure : Sequences of o oeration. Page 5 of 8

6 Queue as a Circular List It is easier to reresent a queue as a circular list than as a linear list. As a linear list, a queue is secified by two ointers, one to the front of the list and the other to its rear. However, by using a circular list, a queue may be secified by a single ointer to that list. The oerations isemty(queue) and remove(queue) are identical with that of stack oerations. void insert(nodetr &queue, int x) Nodetr = (Node)malloc(sizeof(Node)); ->info = x; if(queue==null) queue = ; else ->next = queue->next; queue->next = ; queue = ; The following diagram illustrates the sequences of insert oeration. queue x 5 queue Figure 5: Sequences of insert oeration. Doubly Linked List Although a circularly linked list has advantages over a linear list, it still has several drawbacks. One cannot traverse such a list backward, nor can a node be deleted from a circularly linked list, given only a ointer to that node. In cases, where these facilities are required, the aroriate data structure is a doubly linked list. Each node in such a list contains two ointers, one to its redecessor and another to its successor. It is thus ossible to move either direction through the list while keeing only one ointer. With a doubly linked list, traversals in direction, insertions and deletions from arbitrary ositions in the list can be rogrammed without difficulty. The cost of a doubly linked list, of course, is the extra sace required in each node for a second link. Figure 6: Doubly Linked List. Page 6 of 8

7 Imlementing some oerations int deletenode(nodetr &) nodetr q, r; int res; if(==null) rintf("void deletion."); exit(0); res = ->info; q = ->revious; r = ->next; q->next = r; r->revious = q; free(); return res; q 5 r res Figure 7: Deleting a node from doubly linked list. void insertnodeinright(nodetr &, int x) nodetr n, r = ->next; n = (nodetr)malloc(sizeof(node)); n->revious = r->revious; n->next = ->next; ->next = n; r->revious = n; n->info = x; r 5 6 n Figure 8: Inserting a node in right osition. Page 7 of 8

8 void insertnodeinleft(nodetr &, int x) nodetr n, l; n = (nodetr)malloc(sizeof(node)); n->revious = ->revious; n->next = l->next; l->next = n; ->revious = n; n->info = x; l 5 6 n Circular Doubly Linked List Figure 8: Inserting a node in left osition. In a doubly-circularly-linked list, each node has two links, similar to a doubly-linked list, excet that the revious link of the first node oints to the last node and the next link of the last node oints to the first node. As in a doubly-linked list, insertions and removals can be done at any oint with access to any nearby node. Page 8 of 8

Example: Runtime Memory Allocation: Example: Dynamical Memory Allocation: Some Comments: Allocate and free dynamic memory

Example: Runtime Memory Allocation: Example: Dynamical Memory Allocation: Some Comments: Allocate and free dynamic memory Runtime Memory Allocation: Examle: All external and static variables Global systemcontrol Suose we want to design a rogram for handling student information: tyedef struct { All dynamically allocated variables