Download presentation

Presentation is loading. Please wait.

Published byEdward Clemson Modified over 2 years ago

1
1 abstract containers hierarchical (1 to many) graph (many to many) first ith last sequence/linear (1 to 1) set

2
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
3 tree terminology 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. level 0 1 2 3 4

4
4 trees are recursive Each node is the root of a subtree. Many tree processing algorithms are best written recursively.

5
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 A binary tree is either - empty or - consists of a root and two binary trees, one called the left subtree and one called the right subtree

6
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: 2 n-1 max nodes in binary tree of depth n: 2 n -1 depth of binary tree with k nodes: >floor[log 2 k] depth of binary tree with k nodes:

7
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
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 0 1 2 3 4 5 6 0 1 2 3 4 5 6 - - - - - - - 0 1 2 6 13 works well if n is known in advance and there are no "missing" nodes

9
9 linked representation class binTreeNode { public: T item; binTreeNode * left; binTreeNode * right; binTreeNode (const T & value) { item = value; left = NULL; right = NULL; } }; binTreeNode * root; root left child of *p? right child of *p? parent of *p? p

10
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
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 * -+ 5 2 61 operands are stored in leaf nodes operators are stored in branch nodes

12
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
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
14 traversing an expression tree 4 * + * 1 3- 2 1 preorder (1 st touch) * + 1 3 * - 4 1 2 inorder (2 nd touch) 1 + 3 * 4 - 1 * 2 postorder (last touch) 1 3 + 4 1 - 2 * *

15
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
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
17 Associative Containers fast searching

18
18 STL Containers Sequence containers vector list deque Adapters stack queue priority_queue Associative containers set map multiset multimap unique keys non unique keys keys only set multiset key, value pairs map multimap

19
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
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
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(log 2 n) O(n) O(n) O(n) O(1) O(n) O(n) O(n) O(n) search trees and hash table both have better performance

22
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
23 the BSTree 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
24 an example struct treeItem { int id; // key string data; // value int key( ) const { return id; } }; BSTree myBSTree;

25
25 a binary search tree 36 2042 122439 45 21 40 root This is NOT a Heap!! No node

26
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
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 < key in bstree's root ) search (leftSubtree, searchKey); else search (rightSubtree, searchKey); }

28
28 searching for 40 36 2042 122439 45 21 40 root

29
29 searching for 30 36 2042 122439 45 21 40 root

30
30 Recursive BST Insertion Similar to BST search: Insert_aux (nodeptr & subtree, &item) If (subtree.root.empty( ) ) subtree.root=item Else if (item < subtree.root) Insert_aux (subtree.left, item) // try insert on left Else if (item > subtree.root) Insert_aux (subtree.left, item) // try insert on right Else already in tree Just keep moving down the tree

31
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
32 the easy cases 36 2042 122439 45 21 40 Just prune it Just set its parent (42) to skip this node

33
33 the “hard” case 36 2042 122439 45 21 40

34
34 the “hard” case 36 2042 122439 45 21 40 replace with smallest in right subtree (its inorder successor) replace with largest in left subtree (its inorder predecessor) or

35
35 Using method 1 Replace with in-order predecessor 36 2042 122439 45 21 40

36
36 Method 2 Replace with in-order successor 36 2042 122439 45 21 40

37
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 (log 2 n) maximum: n - 1 average: ?

38
38 faster searching "balanced" search trees guarantee O(log 2 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

Similar presentations

OK

Lecture 9 Binary Trees Trees General Definition Terminology

Lecture 9 Binary Trees Trees General Definition Terminology

© 2018 SlidePlayer.com Inc.

All rights reserved.

Ads by Google

Ppt on teamviewer Ppt on non verbal communication skills Ppt on life and works of william shakespeare Ppt on services in android Ppt on power sharing in democracy supreme Spleen anatomy and physiology ppt on cells Ppt on cross docking charges Ppt on sustainable tourism practices in kenya Free ppt on agriculture in india Ppt on technical topics related to electrical engineering