1. CS201: Data Structures and Discrete Mathematics I Linked Lists, Stacks and Queues

2. 6/7/2014CS 201 Data Structure A construct that can be defined within a programming language to store a collection of data –one may store some data in an array of integers, an array of objects, or an array of arrays

3. 6/7/2014CS 201 Abstract Data Type (ADT) Definition: a collection of data together with a set of operations on that data –specifications indicate what ADT operations do, but not how to implement them –data structures are part of an ADTs implementation Programmer can use an ADT without knowing its implementation.

4. 6/7/2014CS 201 Typical Operations on Data Add data to a data collection Remove data from a data collection Ask questions about the data in a data collection. E.g., what is the value at a particular location, and is x in the collection?

5. 6/7/2014CS 201 Why ADT Hide the unnecessary details Help manage software complexity Easier software maintenance Functionalities are less likely to change Localised rather than global changes

6. 6/7/2014CS 201 Illustration

7. Linked Lists

8. 6/7/2014CS 201 Lists List: a finite sequence of data items a1, a2, a3, …, an Lists are pervasive in computing –e.g. class list, list of chars, list of events Typical operations: –Creation –Insert / remove an element –Test for emptiness –Find an item/element –Current element / next / previous –Find k-th element –Print the entire list

9. 6/7/2014CS 201 Array-Based List Implementation One simple implementation is to use arrays –A sequence of n-elements Maximum size is anticipated a priori. Internal variables: –Maximum size maxSize (m) –Current size curSize (n) –Current index cur –Array of elements listArray n curSize a1a1 a2a2 a3a3 anan listArray unused 012 n-1 m cur

10. 6/7/2014CS 201 Inserting Into an Array While retrieval is very fast, insertion and deletion are very slow – Insert has to shift upwards to create gap a1a1 a2a2 a7a7 a8a8 a4a4 a5a5 a6a6 a3a3 Step 1 : Shift upwards 8 S ize arr 8 a1a1 a2a2 a3a3 a7a7 a8a8 Size arr a4a4 a5a5 a6a6 Example : insert(2, it, arr) Step 2 : Write into gap it Step 3 : Update Size 9

11. 6/7/2014CS 201 Coding typedef struct { int arr[MAX]; int max; int size; } LIST void insert(int j, int it, LIST *pl) { // pre : 1<=j<=size+1 int i; for (i=pl->size; i>=j; i=i-1) // Step 1: Create gap { pl->arr[i+1]= pl->arr[i]; }; pl->arr[j]= it; // Step 2: Write to gap pl->size = pl->size + 1; // Step 3: Update size }

12. 6/7/2014CS 201 Deleting from an Array Delete has to shift downwards to close gap of deleted item Step 1 : Close Gap 9 a1a1 a2a2 it a7a7 a8a8 size a5a5 a6a6 a3a3 a8a8 arr 9 a1a1 a2a2 it a7a7 a8a8 size a4a4 a5a5 a6a6 a3a3 arr Example: deleteItem(4, arr) Step 2 : Update Size 8 Not part of list

13. 6/7/2014CS 201 Coding void delete(int j, LIST *pl) { // pre : 1<=j<=size for (i=j+1; i size; i=i+1) // Step1: Close gap { pl->arr[i-i]=pl->arr[i]; }; // Step 2: Update size pl->size = pl->size - 1; }

14. 6/7/2014CS 201 Linked List Approach Main problem of array is the slow deletion/insertion since it has to shift items in its contiguous memory Solution: linked list where items need not be contiguous with nodes of the form Sequence (list) of four items can be represented by: itemnext aiai a1a1 a2a2 a3a3 a4a4 head represents null

15. Pointer-Based Linked Lists A node in a linked list is usually a struct struct Node { int item Node *next; }; //end struct A node is dynamically allocated Node *p; p = malloc(sizeof(Node)); A node 6/7/2014CS 201

16. Pointer-Based Linked Lists The head pointer points to the first node in a linked list If head is NULL, the linked list is empty –head=NULL head=malloc(sizeof(Node)) 6/7/2014CS 201

17. A Sample Linked List 6/7/2014CS 201

18. Traverse a Linked List Reference a node member with the -> operator p->item; A traverse operation visits each node in the linked list –A pointer variable cur keeps track of the current node for (Node *cur = head; cur != NULL; cur = cur->next) x = cur->item; 6/7/2014CS 201

19. Traverse a Linked List The effect of the assignment cur = cur->next 6/7/2014CS 201

20. Delete a Node from a Linked List Deleting an interior/last node prev->next=cur->next; Deleting the first node head=head->next; Return deleted node to system cur->next = NULL; free(cur); cur=NULL; 6/7/2014CS 201

21. Delete a Node from a Linked List Deleting a node from a linked list Deleting the first node 6/7/2014CS 201

22. Insert a Node into a Linked List To insert a node between two nodes newPtr->next = cur; prev->next = newPtr; Inserting a new node into a linked list CS 201

23. Insert a Node into a Linked List To insert a node at the beginning of a linked list newPtr->next = head; head = newPtr; Inserting at the beginning of a linked list CS 201

24. Insert a Node into a Linked List Inserting at the end of a linked list is not a special case if cur is NULL newPtr->next = cur; prev->next = newPtr; Inserting at the end of a linked list CS 201

25. Look up BOOLEAN lookup (int x, Node *L) { if (L == NULL) return FALSE else if (x == L->item) return TRUE else return lookup(x, L-next); } 6/7/2014CS 201

26. An ADT Interface for List Functions –isEmpty –getLength –insert –delete –Lookup –… Data Members –head –Size Local variables to member functions –cur –prev 6/7/2014CS 201

27. 6/7/2014CS 201 Doubly Liked Lists Frequently, we need to traverse a sequence in BOTH directions efficiently Solution : Use doubly-linked list where each node has two pointers next forward traversal Doubly Linked List. x1x1 x4x4 x2x2 head x3x3 backward traversal prev

28. 6/7/2014CS 201 Circular Linked Lists May need to cycle through a list repeatedly, e.g. round robin system for a shared resource Solution : Have the last node point to the first node x1x1 x2x2 xnxn... Circular Linked List. head

29. Stacks

30. 6/7/2014CS 201 What is a Stack? A stack is a list with the restriction that insertions and deletions can be performed in only one position, namely, the end of the list, called the top. The operations: push (insert) and pop (delete) pop push(o) 6 7 2 3 Top

31. 6/7/2014CS 201 Stack ADT Interface The main functions in the Stack ADT are (S is the stack) boolean isEmpty();// return true if empty boolean isFull(S);// return true if full void push(S, item); // insert item into stack void pop(S); // remove most recent item void clear(S);// remove all items from stack Item top(S); // retrieve most recent item Item topAndPop(S); // return & remove most recent item

32. 6/7/2014CS 201 Sample Operation Stack S = malloc(sizeof(stack)); push(S, a); push(S, b); push(S, c); d=top(S); pop(S); push(S, e); pop(S); s abc top e d

33. 6/7/2014CS 201 Implementation by Linked Lists Can use a Linked List as implementation of stack Top of Stack = Front of Linked-List StackLL lst a1a1 a2a2 a3a3 a4a4 head LinkedListItr

34. 6/7/2014CS 201 Code struct Node { int element; Node * next; }; typedef struct Node * STACK;

35. 6/7/2014CS 201 More code

36. More Code 6/7/2014CS 201

37. 6/7/2014CS 201 Implementation by Array use Array with a top index pointer as an implementation of stack E F 0 1 7 8 9 2 3 4 5 6 A B C D top StackAr arr A

38. 6/7/2014CS 201 Code

39. 6/7/2014CS 201 More code

40. 6/7/2014CS 201 More code

41. Effects 6/7/2014CS 201

42. 6/7/2014CS 201 Applications Many application areas use stacks: –line editing –bracket matching –postfix calculation –function call stack

43. 6/7/2014CS 201 Line Editing A line editor would place characters read into a buffer but may use a backspace symbol (denoted by ) to do error correction Refined Task –read in a line –correct the errors via backspace –print the corrected line in reverse Input : Corrected Input : Reversed Output : abc_defgh 2klpqr wxyz abc_defg2klpwxyz zyxwplk2gfed_cba

44. 6/7/2014CS 201 The Procedure Initialize a new stack For each character read: –if it is a backspace, pop out last char entered –if not a backspace, push the char into stack To print in reverse, pop out each char for output Input : fgh r yz Corrected Input : Reversed Output : fyz zyf Stack f g h r y z

45. 6/7/2014CS 201 Bracket Matching Problem Ensures that pairs of brackets are properly matched An Example: {a,(b+f[4])*3,d+f[5]} Bad Examples: (..)..)// too many closing brackets (..(..)// too many open brackets [..(..]..)// mismatched brackets

46. 6/7/2014CS 201 Informal Procedure Initialize the stack to empty For every char read if open bracket then push onto stack if close bracket, then return & remove most recent item from the stack if doesnt match then flag error if non-bracket, skip the char read Example {a,(b+f[4])*3,d+f[5]} Stack { ( [ ) } ] [ ]

47. 6/7/2014CS 201 Postfix Calculator Computation of arithmetic expressions can be efficiently carried out in Postfix notation with the help of a stack. Infix - arg1 op arg2 Prefix - op arg1 arg2 Postfix - arg1 arg2 op (2*3)+4 2*(3+4) 2 3 4 + * 2*3+4 infix 2 3 * 4 + postfix

48. 6/7/2014CS 201 Informal Procedure Initialise stack S For each item read. If it is an operand, push on the stack If it is an operator, pop arguments from stack; perform operation; push result onto the stack 2 3 4 Stack Expr 2 3 4 + * push(S, 2) push(S, 3) push(S, 4) arg2=topAndPop(S) arg1=topAndPop(S) push(S, arg1+arg2) arg2=topAndPop(S) arg1=topAndPop(S) push(S, arg1*arg2) 3+4=7 2*7=14

49. 6/7/2014CS 201 Summary The ADT stack operations have a last- in, first-out (LIFO) behavior Stack has many applications –algorithms that operate on algebraic expressions –a strong relationship between recursion and stacks exists Stack can be implemented using arrays or linked lists

50. Queues

51. 6/7/2014CS 201 What is a Queue? Like stacks, queues are lists. With a queue, however, insertion is done at one end whereas deletion is done at the other end. Queues implement the FIFO (first-in first-out) policy. E.g., a printer/job queue! Two basic operations of queues: –dequeue: remove an item/element from front –enqueue: add an item/element at the back dequeueenqueue

52. 6/7/2014CS 201 Queue ADT Queues implement the FIFO (first-in first-out) policy –An example is the printer/job queue! enqueue(o) dequeue() isEmpty() getFront() createQueue()

53. 6/7/2014CS 201 Sample Operation Queue *Q; enqueue(Q, a); enqueue(Q, b); enqueue(Q, c); d=getFront(Q); dequeue(Q); enqueue(Q, e); dequeue(Q); q front back abce d

54. 6/7/2014CS 201 Queue ADT interface The main functions in the Queue ADT are (Q is the queue) void enqueue(o, Q) // insert o to back of Q void dequeue(Q); // remove oldest item Item getFront(Q); // retrieve oldest item boolean isEmpty(Q);// checks if Q is empty boolean isFull(Q);// checks if Q is full void clear(Q);// make Q empty }

55. 6/7/2014CS 201 Implementation of Queue (Linked List) Can use LinkedListItr as underlying implementation of Queues a1a1 a2a2 a3a3 a4a4 head tail Queue lst LinkedList addTail

56. 6/7/2014CS 201 Code struct Node { int element; Node * next; }; struct QUEUE { Node * front; Node * rear; };

57. 6/7/2014CS 201 More code

58. 6/7/2014CS 201 CELL is a list node

59. 6/7/2014CS 201 Implementation of Queue (Array) use Array with front and back pointers as implementation of queue Queue arr 0 1 7 8 9 2 3 4 5 6 A B C D E F G front back

60. 6/7/2014CS 201 Circular Array To implement queue, it is best to view arrays as circular structure 0 1 7 8 9 2 3 4 5 6 A B C D E F G front back front back A B C D E F G 0 1 7 8 9 2 3 4 5 6 Circular view of arrays.

61. 6/7/2014CS 201 How to Advance Both front & back pointers should make advancement until they reach end of the array. Then, they should re-point to beginning of the array front = adv(front); back = adv(back); int adv(int p) { return ((p+1) % maxsize); } Alternatively, use modular arithmetic: mod operator int adv(int p) { int r = p+1; if (r<maxsize) return r; else return 0; } upper bound of the array

62. 6/7/2014CS 201 Sample Queue *Q; enqueue(Q, a); enqueue(Q, b); enqueue(Q, c); dequeue(Q); enqueue(Q, d); enqueue(Q, e); dequeue(Q); a Q F=front B=back F B bc d F BBB FF B B e

63. 6/7/2014CS 201 Checking for Full/Empty State What does (F==B) denote? F B Queue Empty State c d e B F f Queue Full State size 0 4 c d e B F Alternative - Leave a Deliberate Gap! No need for size field. Full Case : (adv(B)==F)

64. 6/7/2014CS 201 Summary The definition of the queue operations gives the ADT queue first-in, first-out (FIFO) behavior The queue can be implemented by linked lists or by arrays There are many applications –Printer queues, –Telecommunication queues, –Simulations, –Etc.