1. CS6045: Advanced Algorithms
Data Structures

2. Dynamic Sets Dynamic sets: Dictionary:
Can grow, shrink (manipulated by algorithms)
Change over time
Dictionary:
Insert/delete elements
Test membership

3. Operations Search(S, k)  a pointer to element x with key k (query)
Insert(S, x) add new element pointed to by x, assuming that we have key(x) (modifying)
Delete(S, x) delete x, x is a pointer (modifying)
Minimum(S)/Maximum(S)  max/min (query)
Prede(suc)cessor(S, x)  the next larger/smaller key to the key of element x (query)
Union(S, S’)  new set S = S  S’ (modifying)

4. Stacks Stack (has top), LIFO (last-in first-out) policy 15 6 2 9 17
insert = push (top(S) = top(S)+1); S[top(S)] = x) O(1)
delete = pop O(1) 15 6 2 9 1 3 4 5 7
top = 4 17
top = 5

5. Stacks More operations Operations running time?
Empty stack: contain no elements
Stack underflow: pop an empty stack
Stack overflow: S.top >= n
Operations running time?

6. Queues Queue (has head and tail), FIFO (first-in first-out) policy 15
insert = enqueue (add element to the tail) O(1)
delete = dequeue (remove element from the head) O(1) 15 6 2 9 1 3 4 5 7
tail = 6
head = 2 8

7. Circular Queue

8. Linked List Linked List (objects are arranged in a linear order)
The order is determined by a pointer in each object
Array: the order determined by array indices
Doubly Linked List (has head)
Key, prev, and next attributes x

9. Linked List
Operations:
Search
Insert to the head
Delete x

10. Linked List Running time of linked list operations: Search Insert
Delete

11. Binary Tree Binary Tree has root
Each node has parent, left, and right attributes

12. Binary Search Trees
Binary Search Trees (BSTs) are an important data structure for dynamic sets
Elements have:
key: an identifying field inducing a total ordering
left: pointer to a left child (may be NULL)
right: pointer to a right child (may be NULL)
p: pointer to a parent node (NULL for root)

13. Binary Search Trees BST property: Example: F B H K D A
all keys in the left subtree of key[leftSubtree(x)]  key[x]
all keys in the right subtree of key[x]  key[rightSubtree(x)]
Example: F B H K D A

14. In-Order-Tree Walk What does the following code do?
Prints elements in sorted (increasing) order
This is called an in-order-tree walk
Preorder tree walk: print root, then left, then right
Postorder tree walk: print left, then right, then root 7 5 6 3 2 8 9 4

15. In-Order-Tree Walk Time complexity? O(n)
Prove that in-order-tree walk prints in monotonically increasing order?
By induction on size of tree

16. Operations on BSTs: Search
Given a key and a pointer to a node, returns an element with that key or NULL:
Iterative Tree-Search(x,k)
while k  key[x] do
if k < key[x] then x  x.left
else x  x.right
return x
Which one is more efficient? 7 5 6 3 2 8 9 4
The iterative tree search is more efficient on most computers.
The recursive tree search is more straightforward.

17. Operations on BSTs: Min-Max
MIN: leftmost node
MAX: rightmost node
Running time?
O(h) where h = height of tree 7 5 6 3 2 8 9 4

18. Operations on BSTs: Successor-Predecessor
Successor: the node with the smallest key greater than x.key
x has a right subtree: successor is minimum node in right subtree
x has no right subtree: successor is first ancestor of x whose left child is also ancestor of x
Intuition: As long as you move to the left up the tree, you’re visiting smaller nodes. 15 6 7 3 13 2 18 20 4 17 9

19. Operations of BSTs: Insert
Adds an element x to the tree so that the binary search tree property continues to hold
The basic algorithm
Insert node z, z.key = v, z.left = z.right = NIL
Maintain two pointes:
x: trace the downward path
y: “trailing pointer” to keep track of parent of x
Traverse the tree downward by comparing x.key with v
When x is NIL, it is at the correct position for node z
Compare v with y.key, and insert z at either y’s left or right, appropriately

20. BST Insert: Example
Example: Insert C F B H K D A C

21. BST Search/Insert: Running Time
What is the running time of TreeSearch() or TreeInsert()?
A: O(h), where h = height of tree
What is the height of a binary search tree?
A: worst case: h = O(n) when tree is just a linear string of left or right children
Average case: h=O(lg n)

22. Sorting With BSTs It’s a form of quicksort! for i=1 to n
TreeInsert(A[i]);
InorderTreeWalk(root); 3 1 8
1 2 2 6 2
6 7 5 5 7 5 7

23. Sorting with BSTs
Which do you think is better, quicksort or BSTSort? Why?
A: quicksort
Sorts in place
Doesn’t need to build data structure

24. BST Operations: Delete
Deletion is a bit tricky
3 cases:
x has no children:
Remove x 7 5 6 3 2 8 9 4

25. BST Operations: Delete
3 cases:
x has no children: Remove x
x has one child: Splice out x
x has two children:
Swap x with successor
Perform case 1 or 2 to delete it 7 5 6 3 2 8 9 4 z z
successor(z)
exchange 7 5 6 2 1 8 9 3 4

26. BST Operations: Delete
Why will case 2 always go to case 0 or case 1?
A: because when x has 2 children, its successor is the minimum in its right subtree, and that successor has no left child (hence 0 or 1 child).
Could we swap x with predecessor instead of successor?
A: yes.
Would it be a good idea?
A: might be good to alternate to avoid creating unbalanced tree.