Basic Data Structures

1. Basic Data Structures CS 583 Analysis of Algorithms CS583 Fall'06: Basic Data Structures

2. Outline • HW1 analysis • Basic Data Structures • Stacks • Queues • Linked lists • Rooted trees • Binary Search Trees • Tree walk • Querying CS583 Fall'06: Basic Data Structures

3. HW1 • HW1 answers are posted on the web site • Check results by e-mail to the TA, or with the instructor in the class • The grade can be changed within 1 week, by October 9. • Submitting HW in the future: • Attach the submission in a separate file, and double-check that it’s not empty. • Prefix the file name with the student’s last name, e.g. JonesHw1.doc. • Indent a pseudocode properly. CS583 Fall'06: Basic Data Structures

4. Stacks • Stack is a dynamic data set in which the element deleted from the set is the latest inserted: last-in-first-out, or LIFO policy. • The insert operation on stack is often called PUSH • The delete operation is often called POP. • A stack can be implemented by an array S[1..n] with an attribute top[S] that indexes the most recently inserted element. • When top[S] = 0, the stack is empty. • If an empty stack is popped, we say the stack underflows. • When top[S] > n, the stack overflows. CS583 Fall'06: Basic Data Structures

5. Stack Algorithms Stack-Empty(S) 1 if top[S] = 0 2 return TRUE 3 else 4 return FALSE Push(S, x) 1 top[S]++ 2 S[top[S]] = x Pop(S) 1 if Stack-Empty(S) 2 throw "underflow" 3 else 4 top[S]— 5 return S[top[S]+1] Each of above algorithms runs in O(1) time. CS583 Fall'06: Basic Data Structures

6. Queues • The queue implements a first-in-first-out, or FIFO policy. • The insert operation on a queue is called ENQUEUE • The delete operation is called DEQUEUE. • A queue of at most (n-1) elements can be implemented using an array Q[1..n]. • The queue has an attribute head[Q] that points to the index of its head. • The attribute tail[Q] indexes the next location at which the new element will be inserted. • The order is circular, i.e. the location 1 immediately follows the location n. CS583 Fall'06: Basic Data Structures

7. Queues: Example 1 2 3 4 5 13 11 12 Q[1..5] tail head 11 = Dequeue(Q): 1 2 3 4 5 13 12 Q[1..5] tail head Enqueue(Q,14): 1 2 3 4 5 13 14 12 Q[1..5] tail head CS583 Fall'06: Basic Data Structures

8. Queue Algorithms Enqueue(Q,x) 1 /* head and tail cannot point to the same location,hence only (n-1) elements can be stored */ 2 if tail[Q] + 1 = head[Q] 3 throw "overflow" 4 Q[tail[Q]] = x 5 tail[Q] = tail[Q] % n + 1 // wrap around CS583 Fall'06: Basic Data Structures

9. Queue Algorithms (cont.) Dequeue(Q) 1 if head[Q]=tail[Q] 2 throw "underflow" 3 x = Q[head[Q]] 4 head[Q] = head[Q] % n + 1 // wrap around 5 return x Both operations run in O(1) time. CS583 Fall'06: Basic Data Structures

10. Linked Lists • A linked list is a data structure in which objects are arranged in linear order. • Each object points to the location of the next object. • In a doubly linked list each object also points to the location of the previous object. • More formally, for a doubly linked list L: • head[L] points to the first element of the list. • Given an element x from L: • prev[x] points to its predecessor. • next[x] points to its successor. • If next[x] = NIL, x is the last element in L. • If prev[x] = NIL, x is the first element in L. CS583 Fall'06: Basic Data Structures

11. Linked Lists Algorithms The following algorithm finds the first element with key k in the list L: List-Search(L,k) 1 x = head[L] 2 while x <> NIL and key[x] <> k 3 x = next[x] 4 return x The above algorithm runs in (n) time in the worst case, since it may have to search the entire list. CS583 Fall'06: Basic Data Structures

12. Linked Lists Algorithms (cont.) The following algorithm inserts an element x with a key set to the front of the list. List-Insert(L,x) 1 next[x] = head[L] 2 if head[L] <> NIL 3 prev[head[L]] = x 4 head[L] = x 5 prev[x] = NIL The running time of the insert algorithm is O(1). CS583 Fall'06: Basic Data Structures

13. Linked Lists Algorithms (cont.) The following algorithm deletes an element x from the linked list. (It assumes the pointer to x is known, otherwise use List-Search to find x according to some key). List-Delete(L,x) 1 if prev[x] <> NIL 2 next[prev[x]] = next[x] 3 else 4 head[L] = next[x] 5 if next[x] <> NIL 6 prev[next[x]] = prev[x] This algorithm runs in O(1), however it would require (n) time if it needs to search for an element. CS583 Fall'06: Basic Data Structures

14. Rooted Trees • Trees can be represented using linked data structures. • For example, in case of binary trees we use fields p, left, and right to store pointers to the parent, left child, and right child of each node of the binary tree T. • The root of the tree is root[T] (x: p[x] = NIL).  • To represent trees with unbounded branching, we use binary tree representation. • In this scheme, each node still contains a parent pointer, and root[T] points to the root of T. Instead of having a pointer for each child of a node, each node x has only two pointers:  • left-child[x] points to the leftmost child of node x. • right-sibling[x] points to the sibling of x immediately to the right. • If node x has no children, then left-child[x] = NIL. • If node x is the rightmost child of its parent, then right-sibling[x] = NIL. CS583 Fall'06: Basic Data Structures

15. Binary Search Tree • Binary search tree is a binary tree that stores keys and satellite data. The keys are stored in such a way to satisfy the following property:  • Let x be a node in a BST. If y is a node in left subtree of x, then key[y] <= key[x]. If y is a node in the right subtree of x, then key[x] <= key[y]. • The above property allows us to print out all keys in a BST in sorted order by an inorder tree walk algorithm (left, root, right). • Similar algorithms include preorder tree walk (root, left, right), and postorder tree walk (left, right, root). CS583 Fall'06: Basic Data Structures

16. Inorder Tree Walk • Inorder-Tree-Walk (x) • 1 if x <> NIL • 2 Inorder-Tree-Walk(left[x]) • 3 print key[x] • 4 Inorder-Tree-Walk(right[x]) • It takes (n) to walk an n-node BST, since the procedure is called exactly twice for each node of the tree (left and right child) + printing the node. We prove it formally as follows. • Theorem 12.1 • If x is the root of an n-node subtree, then Inorder-Tree-Walk(x) takes (n)time. CS583 Fall'06: Basic Data Structures

17. Inorder Tree Walk: Performance Proof. On an empty subtree Inorder-Tree-Walk(x) takes a constant time (to compare to NIL), so T(0) = c for some positive constant c. For n>0, suppose the procedure is called on a node x, whose left subtree has k nodes, and the right subtree has (n-k-1) nodes. The time to perform the algorithm is: T(n) = T(k) + T(n-k-1) + d, where d is time to print x. CS583 Fall'06: Basic Data Structures

18. Inorder Tree Walk: Performance (cont.) We use the substitution method to show that T(n) = (c+d)n + c. For n=0: T(0) = c. For n>0 we have: T(n) = T(k) + T(n-k-1) + d = ((c+d)k + c) + ((c+d)(n-k-1) + c) + d = ck + dk + c +cn –ck –c + dn –dk –d + c + d = cn + dn + c = (c+d)n + c  CS583 Fall'06: Basic Data Structures

19. BST: Querying We use the following procedure to search for a node in BST: Tree-Search(x,k) Input: root x and key k Output: pointer to a node with key k, or NIL if not found 1 if x = NIL or k=key[x] 2 return x 3 if k < key[x] 4 return Tree-Search(left[x],k) 5 else 6 return Tree-Search(right[x],k) The nodes encountered form a path downward from the root of the tree, hence the running time of search is O(h), where h is the height of the tree. CS583 Fall'06: Basic Data Structures

20. BST: Minimum and Maximum Minimum and maximum elements in BST can be found by following the left, or the right subtree respectively: Tree-Minimum(x) 1 while left[x] <> NIL 2 x = left[x] 3 return x Tree-Maximum(x) 1 while right[x] <> NIL 2 x = right[x] 3 return x CS583 Fall'06: Basic Data Structures

21. BST: Finding Successor If all keys are distinct, the successor of the node x is the smallest key greater than key[x]. Tree-Successor(x) 1 if right[x] <> NIL 2 return Tree-Minimum(right[x]) 3 y = parent[x] 4 while y <> NIL and x = right[y] 5 x = y 6 y = parent[y] 7 return y When the right subtree is empty, the successor of x is the lowest ancestor of x, whose left child is also ancestor of x (lines 3-7). To find such ancestor, we find the first one that is not on the "right subtree" path to x. The running time of the above algorithm is O(h) since we either follow a path down or up from the node. CS583 Fall'06: Basic Data Structures