Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is...
-
date post
20-Dec-2015 -
Category
Documents
-
view
219 -
download
0
Transcript of Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is...
![Page 1: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/1.jpg)
Trees, Binary Trees, and Binary Search Trees
![Page 2: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/2.jpg)
2
Trees
Linear access time of linked lists is prohibitive Does there exist any simple data structure for
which the running time of most operations (search, insert, delete) is O(log N)?
Trees Basic concepts Tree traversal Binary tree Binary search tree and its operations
![Page 3: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/3.jpg)
3
Trees A tree T is a collection of nodes
T can be empty (recursive definition) If not empty, a tree T consists
of a (distinguished) node r (the root), and zero or more nonempty sub-trees T1, T2, ...., Tk
![Page 4: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/4.jpg)
4
Tree can be viewed as a ‘nested’ lists Tree is also a graph …
![Page 5: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/5.jpg)
5
Some Terminologies
Child and Parent Every node except the root has one parent A node can have a zero or more children
Leaves Leaves are nodes with no children
Sibling nodes with same parent
![Page 6: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/6.jpg)
6
More Terminologies
Path A sequence of edges
Length of a path number of edges on the path
Depth of a node length of the unique path from the root to that node
Height of a node length of the longest path from that node to a leaf all leaves are at height 0
The height of a tree = the height of the root = the depth of the deepest leaf
Ancestor and descendant If there is a path from n1 to n2 n1 is an ancestor of n2, n2 is a descendant of n1 Proper ancestor and proper descendant
![Page 7: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/7.jpg)
7
Example: UNIX Directory
![Page 8: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/8.jpg)
8
Tree Traversal
Used to print out the data in a tree in a certain order
Pre-order traversal Print the data at the root Recursively print out all data in the leftmost subtree … Recursively print out all data in the rightmost
subtree
![Page 9: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/9.jpg)
9
Example: Unix Directory TraversalPreOrder PostOrder
![Page 10: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/10.jpg)
10
Binary Trees A tree in which no node can have more than two
children
The depth of an “average” binary tree is considerably smaller than N, even though in the worst case, the depth can be as large as N – 1.
Generic binary tree
Worst-casebinary tree
![Page 11: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/11.jpg)
11
Convert a Generic Tree to a Binary Tree
![Page 12: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/12.jpg)
12
Binary Tree ADT
Possible operations on the Binary Tree ADT Parent, left_child, right_child, sibling, root, etc
Implementation Because a binary tree has at most two children, we can keep
direct pointers to them a linked list is physically a pointer, so is a tree.
Define a Binary Tree ADT later …
![Page 13: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/13.jpg)
13
A drawing of linked list with one pointer …
A drawing of binary tree with two pointers …
Struct BinaryNode {
double element; // the data
BinaryNode* left; // left child
BinaryNode* right; // right child
}
![Page 14: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/14.jpg)
14
Example: Expression Trees
Leaves are operands (constants or variables) The internal nodes contain operators Will not be a binary tree if some operators are not
binary
![Page 15: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/15.jpg)
15
Preorder, Postorder and Inorder
Preorder traversal node, left, right prefix expression
++a*bc*+*defg
![Page 16: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/16.jpg)
16
Preorder, Postorder and Inorder
Postorder traversal left, right, node postfix expression
abc*+de*f+g*+
Inorder traversal left, node, right infix expression
a+b*c+d*e+f*g
![Page 17: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/17.jpg)
17
Preorder, Postorder and Inorder Pseudo Code
![Page 18: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/18.jpg)
18
Binary Search Trees (BST) A data structure for efficient searching, inser-
tion and deletion Binary search tree property
For every node X All the keys in its left
subtree are smaller than the key value in X
All the keys in its right subtree are larger than the key value in X
![Page 19: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/19.jpg)
19
Binary Search Trees
A binary search tree Not a binary search tree
![Page 20: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/20.jpg)
20
Binary Search Trees
Average depth of a node is O(log N) Maximum depth of a node is O(N)
The same set of keys may have different BSTs
![Page 21: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/21.jpg)
21
Searching BST If we are searching for 15, then we are done. If we are searching for a key < 15, then we
should search in the left subtree. If we are searching for a key > 15, then we
should search in the right subtree.
![Page 22: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/22.jpg)
22
![Page 23: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/23.jpg)
23
Searching (Find) Find X: return a pointer to the node that has
key X, or NULL if there is no such node
Time complexity: O(height of the tree)
find(const double x, BinaryNode* t) const
![Page 24: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/24.jpg)
24
Inorder Traversal of BST Inorder traversal of BST prints out all the keys
in sorted order
Inorder: 2, 3, 4, 6, 7, 9, 13, 15, 17, 18, 20
![Page 25: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/25.jpg)
25
findMin/ findMax Goal: return the node containing the smallest (largest)
key in the tree Algorithm: Start at the root and go left (right) as long as
there is a left (right) child. The stopping point is the smallest (largest) element
Time complexity = O(height of the tree)
BinaryNode* findMin(BinaryNode* t) const
![Page 26: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/26.jpg)
26
Insertion Proceed down the tree as you would with a find If X is found, do nothing (or update something) Otherwise, insert X at the last spot on the path traversed
Time complexity = O(height of the tree)
![Page 27: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/27.jpg)
27
void insert(double x, BinaryNode*& t)
{
if (t==NULL) t = new BinaryNode(x,NULL,NULL);
else if (x<t->element) insert(x,t->left);
else if (t->element<x) insert(x,t->right);
else ; // do nothing
}
![Page 28: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/28.jpg)
28
Deletion
When we delete a node, we need to consider how we take care of the children of the deleted node. This has to be done such that the property of the
search tree is maintained.
![Page 29: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/29.jpg)
29
Deletion under Different Cases Case 1: the node is a leaf
Delete it immediately
Case 2: the node has one child Adjust a pointer from the parent to bypass that node
![Page 30: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/30.jpg)
30
Deletion Case 3 Case 3: the node has 2 children
Replace the key of that node with the minimum element at the right subtree
(or replace the key by the maximum at the left subtree!)
Delete that minimum element Has either no child or only right child because if it has a left child,
that left child would be smaller and would have been chosen. So invoke case 1 or 2.
Time complexity = O(height of the tree)
![Page 31: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/31.jpg)
31
void remove(double x, BinaryNode*& t)
{
if (t==NULL) return;
if (x<t->element) remove(x,t->left);
else if (t->element < x) remove (x, t->right);
else if (t->left != NULL && t->right != NULL) // two children
{
t->element = finMin(t->right) ->element;
remove(t->element,t->right);
}
else
{
Binarynode* oldNode = t;
t = (t->left != NULL) ? t->left : t->right;
delete oldNode;
}
}
![Page 32: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/32.jpg)
32
Insertion Example Construct a BST successively from a sequence of data: 35,60,2,80,40,85,32,33,31,5,30
![Page 33: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/33.jpg)
33
Deletion Example Removing 40 from (a) results in (b) using the smallest
element in the right subtree (i.e. the successor)
5
30
2
40
8035
32
3331
8560
5
30
2
60
8035
32
3331
85
(a) (b)
![Page 34: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/34.jpg)
34
Removing 40 from (a) results in (c) using the largest element in the left subtree (i.e., the predecessor)
COMP152 34
5
30
2
40
8035
32
3331
8560
(a) (c)
5
30
2
35
8032
3331 8560
![Page 35: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/35.jpg)
35
Removing 30 from (c), we may replace the element with either 5 (predecessor) or 31 (successor). If we choose 5, then (d) results.
COMP152 35
(c)
5
30
2
35
8032
3331 8560
(d)
2
5
35
8032
3331 8560
![Page 36: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/36.jpg)
36
Example: compute the number of nodes?
![Page 37: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/37.jpg)
37
Search trees 37
Example: SuccessorThe successor of a node x is
defined as: The node y, whose key(y) is the successor of
key(x) in sorted order sorted order of this tree. (2,3,4,6,7,9,13,15,17,18,20)
Successor of 2Successor of 6
Successor of 13
Some examples:
Which node is the successor of 2?Which node is the successor of 9?Which node is the successor of 13?Which node is the successor of 20? Null
Successor of 9
![Page 38: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/38.jpg)
38
Search trees 38
Finding Successor:Three Scenarios to Determine Successor
Successor(x)
x has right descendants=> minimum( right(x) )
x has no right descendants
x is the left child of some node=> parent(x)
x is the right child of some node
Scenario I
Scenario II Scenario III
![Page 39: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/39.jpg)
39
Search trees 39
Scenario I: Node x Has a Right Subtree
By definition of BST, all items greater thanx are in this right sub-tree.
Successor is the minimum( right( x ) )
maybe null
![Page 40: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/40.jpg)
40
Search trees 40
Scenario II: Node x Has No Right Subtree and x is the Left
Child of Parent (x)
Successor is parent( x )
Why? The successor is the node whosekey would appear in the next sorted order.
Think about traversal in-order. Who wouldbe the successor of x?
The parent of x!
![Page 41: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/41.jpg)
41
Search trees 41
Scenario III: Node x Has No Right Subtree and Is Not a Left-Child of an
Immediate Parent
Keep moving up the tree untilyou find a parent which branchesfrom the left().Successor of x
Stated in Pseudo code.y
x
![Page 42: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/42.jpg)
42
Search trees 42
Successor Pseudo-Codes
Scenario I
Scenario III
Verify this codewith this tree.
Find successor of 3 49 1313 1518 20
Scenario II
Note that parent( root ) = NULL
![Page 43: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/43.jpg)
43
Search trees 43
Problem If we use a “doubly linked” tree, finding parent is easy.
But usually, we implement the tree using only pointers to the left and right node. So, finding the parent is tricky.
For this implementation we need to use a Stack.
class Node{
int data;Node * left;Node * right;Node *
parent;};
class Node{
int data;Node * left;Node *
right;};
![Page 44: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/44.jpg)
44
Search trees 44
Use a Stack to Find SuccessorPART IInitialize an empty Stack s.
Start at the root node, and traverse the tree until we find the node x. Push all visited nodes onto the stack.
PART IIOnce node x is found, find successorusing 3 scenarios mentioned before.
Parent nodes are found by popping the stack!
![Page 45: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/45.jpg)
45
Search trees 45
An Example
15
6
7
Stack s
Successor(root, 13)Part I Traverse tree from root to find 13 order -> 15, 6, 7, 13
push(15)
push(6)
push(7)
13 found (x = node 13)
![Page 46: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/46.jpg)
46
Search trees 46
Example
15
6
7
Stack s
Successor(root, 13)Part II Find Parent (Scenario III) y=s.pop() while y!=NULL and x=right(y) x = y; if s.isempty() y=NULL else y=s.pop() loop return y
y =pop()=15 ->Stop right(15) != x return y as successor!
x = 13
y =pop()=7
y =pop()=6
![Page 47: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/47.jpg)
47
Make a binary or BST ADT …
![Page 48: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/48.jpg)
48
Struct Node {
double element; // the data
Node* left; // left child
Node* right; // right child
}
class Tree {
public:
Tree(); // constructor
Tree(const Tree& t);
~Tree(); // destructor
bool empty() const;
double root(); // decomposition (access functions)
Tree& left();
Tree& right();
bool search(const double x);
void insert(const double x); // compose x into a tree
void remove(const double x); // decompose x from a tree
private:
Node* root;
}
For a generic (binary) tree:
(insert and remove are different from those of BST)
![Page 49: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/49.jpg)
49
Struct Node {
double element; // the data
Node* left; // left child
Node* right; // right child
}
class BST {
public:
BST(); // constructor
BST(const Tree& t);
~BST(); // destructor
bool empty() const;
double root(); // decomposition (access functions)
BST& left();
BST& right();
bool serch(const double x); // search an element
void insert(const double x); // compose x into a tree
void remove(const double x); // decompose x from a tree
private:
Node* root;
}
For BST tree:
BST is for efficient search, insertion and removal, so restricting these functions.
![Page 50: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/50.jpg)
50
class BST {
public:
BST();
BST(const Tree& t);
~BST();
bool empty() const;
bool search(const double x); // contains
void insert(const double x); // compose x into a tree
void remove(const double x); // decompose x from a tree
private:
Struct Node {
double element;
Node* left;
Node* right;
Node(…) {…}; // constructuro for Node
}
Node* root;
void insert(const double x, Node*& t) const; // recursive function
void remove(…)
Node* findMin(Node* t);
void makeEmpty(Node*& t); // recursive ‘destructor’
bool contains(const double x, Node* t) const;
}
Weiss textbook:
![Page 51: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/51.jpg)
51
root, left subtree, right subtree are missing:
1. we can’t write other tree algorithms, is implementation dependent,
BUT,
2. this is only for BST (we only need search, insert and remove, may not need other tree algorithms)
so it’s two layers, the public for BST, and the private for Binary Tree.
3. it might be defined internally in ‘private’ part (actually it’s implicitly done).
Comments:
![Page 52: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/52.jpg)
52
void insert(double x, BinaryNode*& t)
{
if (t==NULL) t = new BinaryNode(x,NULL,NULL);
else if (x<t->element) insert(x,t->left);
else if (t->element<x) insert(x,t->right);
else ; // do nothing
}
void insert(double x)
{
insert(x,root);
}
A public non-recursive member function:
A private recursive member function:
![Page 53: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/53.jpg)
53
Struct Node {
double element; // the data
Node* left; // left child
Node* right; // right child
}
Class BinaryTree {
…
}
class BST : public BinaryTree {
}
void BST::search () {
}
void BST::insert () {
}
void BST::delete () {
}
By inheritance
All search, insert and deletion have to be redefined.
template<typename T>
Struct Node {
T element; // the data
Node* left; // left child
Node* right; // right child
}
template<typename T>
class BinaryTree {
…
}
template<typename T>
class BST : public BinaryTree<T> {
}
void BST<T>::search (const T& x) {
}
void BST<T>::insert (…) {
}
void BST<T>::delete (…) {
}
![Page 54: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/54.jpg)
54
More general BST …template<typename T>
Struct Node {
T element; // the data
Node* left; // left child
Node* right; // right child
}
template<typename T>
class BinaryTree {
…
}
template<typename T>
class BST : public BinaryTree<T> {
}
void BST<T>::search (const T& x) {
}
void BST<T>::insert (…) {
}
void BST<T>::delete (…) {
}
template<typename T>
class BinaryTree {
…
}
template<typename T, typename K>
class BST : public BinaryTree<T> {
}
void BST<T>::search (const K& key) {
}
Search ‘key’ of K might be different from the data record of T!!!
![Page 55: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/55.jpg)
55
Deletion Code (1/4) First Element Search, and then Convert Case III, if any,
to Case I or II
COMP152 55
template<class E, class K>BSTree<E,K>& BSTree<E,K>::Delete(const K& k, E& e){
// Delete element with key k and put it in e.// set p to point to node with key k (to be deleted)BinaryTreeNode<E> *p = root, // search pointer
*pp = 0; // parent of pwhile (p && p->data != k){
// move to a child of ppp = p;if (k < p->data) p = p->LeftChild;else p = p->RightChild;
}
![Page 56: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/56.jpg)
56
Deletion Code (2/4)
56
if (!p) throw BadInput(); // no element with key k
e = p->data; // save element to delete
// restructure tree// handle case when p has two childrenif (p->LeftChild && p->RightChild) {
// two children convert to zero or one child case// find predecessor, i.e., the largest element in // left subtree of pBinaryTreeNode<E> *s = p->LeftChild,*ps = p; // parent of swhile (s->RightChild) {
// move to larger elementps = s;s = s->RightChild;}
![Page 57: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/57.jpg)
57
Deletion Code (3/4)
COMP152 57
// move from s to pp->data = s->data;p = s; // move/reposition pointers for deletionpp = ps;
}
// p now has at most one child// save child pointer to c for adoptionBinaryTreeNode<E> *c;if (p->LeftChild) c = p->LeftChild;else c = p->RightChild;
// deleting pif (p == root) root = c; // a special case: delete rootelse {
// is p left or right child of pp?if (p == pp->LeftChild) pp->LeftChild = c;//adoptionelse pp->RightChild = c;}
![Page 58: Trees, Binary Trees, and Binary Search Trees. 2 Trees * Linear access time of linked lists is prohibitive n Does there exist any simple data structure.](https://reader035.fdocuments.net/reader035/viewer/2022062421/56649d415503460f94a1b752/html5/thumbnails/58.jpg)
58
Deletion Code (4/4)
COMP152 58
delete p;
return *this;}