abstract containers

1
abstract containers
2
trees

• hierarchical organization
• each item has 1 predecessor and 0 or more
  successors
• one item (root) has 0 predecessors
• general tree - no limit on number of successors
• binary tree - 2 successors (left and right)
• binary search tree is one use of a binary tree
  data structure (will deal with later)

3
tree terminology
level 0 1 2 3 4
There is a unique path from the root to each
node. Root is a level 0, child is at
level(parent) 1. Depth/height of a tree is the
length of the longest path.
4
trees are recursive
Each node is the root of a subtree. Many tree
processing algorithms are best written
recursively.
5
binary tree

• Each node has two successors
• one called the left child
• one called the right child
• left child and/or right child may be empty

6
binary tree density (shape)

• a binary tree of depth n is complete iff
• levels 1 .. n have all possible nodes filled-in
• level 1 1
• level 2 2
• level 3 4
• level n ?
• nodes at level n occupy the leftmost positions
• max nodes level at n 2n-1
• max nodes in binary tree of depth n 2n-1
• depth of binary tree with k nodes gtfloorlog2 k
• depth of binary tree with k nodes ltceillog2 k
• longest path is O(log2 k)

7
representing a binary tree

• have to store items and relationships
  (predecessor and successors information)
• array representation
• each item has a position number (0 .. n-1)
• use the position number as an array index
• O(1) access to parent and children of item at
  position i
• wastes space unless binary tree is complete
• linked representation
• each item stored in a node which contains
• the item
• a pointer to the left subtree
• a pointer to the right subtree

8
array representation

• each item has a position number
• root is at position 0
• root's left child is at position 1
• root's right child is at position 2
• in general
• left child of i is at 2i 1
• right child of i is at 2i 2
• parent of i is at (i-1)/2

works well if n is known in advance and there are
no "missing" nodes
9
linked representation
class binTreeNode public T item
binTreeNode left binTreeNode right
binTreeNode (const T value)
item value left NULL
right NULL binTreeNode root
left child of p? right child of p? parent of p?
10
why is a binary tree so useful?

• for storing a collection of values that has a
  binary hierarchical organization
• arithmetic expressions
• boolean logic expressions
• Morse or Huffman code trees
• data structure for a binary search tree
• general tree can be stored using a binary tree
  data structure

11
an expression tree

• an arithmetic expression consists of an operator
  and two operands (either of which may be an
  arithmetic expression)
• some simplifications
• only binary operators (, , /, -)
• only single digit, non-negative integer operands

operands are stored in leaf nodes operators are
stored in branch nodes
12
traversing a binary tree

• what does it mean to traverse a container?
• "visit" each item once in some order
• many operations on a collection of items involve
  traversing the container in which they are stored
• displaying all items
• making a copy of a container
• linear collections (usually) traversed from first
  to last
• last to first is an alternative traversal order

13
binary tree traversals

• order in which to "visit" the items?
• some common orders - visit an item
• before its children (preorder)
• after its children (postorder)
• between its children (inorder)
• level by level (level order)
• by convention go left before right

14
traversing an expression tree
preorder (1st touch) 1 3 - 4 1 2



postorder (last touch) 1 3 4 1 - 2
2
1
3
-
inorder (2nd touch) 1 3 4 - 1 2
4
1
15
expression tree traversal
traverse (ExprTree) if (root of ExprTree
holds a digit) //is a leaf node visit
(root) else // root holds an operand
visit (root) traverse
(ExprTree's left subtree) traverse
(ExprTree's right subtree)
16
expression tree operations

• use "recursive partners"
• allow recursive calls to deal with a subtree
  (identifed by a pointer to its root node)
• build uses a preorder traversal
• copy uses a preorder traversal
• postfix uses a postorder traversal
• clear uses a postorder traversal
• what kind of traversal does infix need?
• what kind of traversal does evaluate need?

17
Associative Containers

• fast searching

18
STL Containers

• Sequence containers
• vector
• list
• deque
• Adapters
• stack
• queue
• priority_queue

• Associative containers
• set
• map
• multiset
• multimap

19
map containers

• allow storing a collection of items each of which
  has a key which uniquely identifies it
• student records (social security number)
• books in a library (ISBN)
• identifiers appearing in a function (name)
• has operations to
• insert an item (key-value pair)
• delete the item with a given key
• retrieve the item with a given key
• operations based on value, not position
• searching for a key is the critical operation

20
some possible data structures

• array (or STL vector)
• unordered
• ordered by keys
• linked list (or STL list)
• unordered
• ordered by keys
• binary search tree
• balanced search trees
• hash table

21
comparative performance
data structure Retrieve Insert
Delete unordered array ordered
array unordered linked list ordered linked
list
O(n) O(1) O(n)
O(log2n) O(n) O(n)
O(n) O(1) O(n)
O(n) O(n) O(n)
22
binary search tree

• each item is stored in a node of a binary tree
• each node is the root of a binary tree with the
  BST property
• all items stored in its left subtree have smaller
  key values
• all items stored in its right subtree have larger
  key values
• May be lop-sided. Insertion order matters.

23
the BSTreeltTE, KFgt class

• BSTreeNode has same structure as binary tree
  nodes
• elements stored in a BSTree are a key-value pair
• must be a class (or a struct) which has
• a data member for the value
• a data member for the key
• a method with the signature KT key( ) const
  where KT is the type of the key

24
an example
struct treeItem int id // key
string data // value int key( )
const return id
BSTreelttreeItem, intgt myBSTree

25
a binary search tree
root
36
This is NOT a Heap!!
20
42
45
12
24
39
21
No node
40
26
traversing a binary search tree

• can use any of the binary tree traversal orders
  preorder, inorder, postorder
• base case is reaching an empty tree
• inorder traversal visits the elements in order of
  their key values
• how would you visit the elements in descending
  order of key values?

27
Recursive BST Search Algorithm
void search (bstree, searchKey) if (bstree is
empty) //base case item not found.
Take needed action else if (key in bstree's
root search Key) // base
case item found. Process it. else if
(searchKey lt key in bstree's root )
search (leftSubtree, searchKey)
else search
(rightSubtree, searchKey)
28
searching for 40
root
36
20
42
45
12
24
39
21
40
29
searching for 30
root
30
Recursive BST Insertion

• Similar to BST search
• Insert_aux (nodeptr subtree, item)
• If (subtree.root.empty( ) ) subtree.rootitem
• Else if (item lt subtree.root)
• Insert_aux (subtree.left, item) // try
  insert on left
• Else if (item gt subtree.root)
• Insert_aux (subtree.left, item) // try insert on
  right
• Else already in tree
• Just keep moving down the tree

31
deletion cases

• item to be deleted is in a leaf node
• pointer to its node (in parent) must be changed
  to NULL
• item to be deleted is in a node with one empty
  subtree
• pointer to its node (in parent) must be changed
  to the non-empty subtree
• item to be deleted is in a node with two
  non-empty subtrees

32
the easy cases
Just set its parent (42) to skip this node
Just prune it
33
the hard case
34

the hard case
or
replace with smallest in right subtree (its
inorder successor)
replace with largest in left subtree (its
inorder predecessor)
35
Using method 1

• Replace with in-order predecessor

36
20
42
45
12
24
39
21
40
36
Method 2

• Replace with in-order successor

36
20
42
45
12
24
39
21
40
37
big O of BST operations

• measured by length of the search path
• depends on the height of the BST
• height determined by order of insertion
• height of a BST containing n items is
• minimum floor (log2 n)
• maximum n - 1
• average ?

38
faster searching

• "balanced" search trees guarantee O(log2 n)
  search path by controlling height of the search
  tree
• AVL tree
• 2-3-4 tree
• red-black tree (used by STL associative container
  classes)
• hash table allows for O(1) search performance
• search time does not increase as n increases