examines every node of a list until a matching node is found, or until all nodes have been examined and no match is found.

Transcription

1

2 A examines every node of a list until a matching node is found, or until all nodes have been examined and no match is found. For very long lists that are frequently searched, this can take a large amount of time... sometimes, too much time

3 To search faster, other algorithms, sometimes using non-linear data structures, are needed. One such data structure is the

4 Each node has: - a member - a pointer (to node) - a pointer (to node) The node pointed to by is called the The node pointed to by is called the The node itself may be called the

5 A BST consists of a (pointer to node) which is: - NULL for Empty, or - Points to the first node in the BST, called the

6 For every node in a BST: - points to the root of a (sub) BST - points to the root of a (sub) BST - is - greater than or equal to the keys of all nodes in the left subtree - less than all notes in the right subtree.

7

8 Given: - root of a (sub) BST, If is EMPTY NOT FOUND! else if == FOUND! else if < search for else ( > ) search for - a value to search for

9 Given: - root of a (sub) BST, If is EMPTY NOT FOUND! else if == FOUND! else if < search for - a value to search for

10 Given: - root of a (sub) BST, If is EMPTY NOT FOUND! else if == FOUND! - a value to search for else ( > ) search for for

11 Given: - root of a (sub) BST, If is EMPTY NOT FOUND! else if == FOUND! else if < search for - a value to search for

12 Given: - root of a (sub) BST, If is EMPTY NOT FOUND! - a value to search for else if < search else ( > ) search for for

13 Given: - root of a (sub) BST - pointer to a new node to insert If is EMPTY make point to else if key of <= key of insert into 's child else insert into 's child

14 Given: - root of a (sub) BST - pointer to new node If is EMPTY make point to else insert into 's child

15 Given: - root of a (sub) BST - a new node to insert If is EMPTY make point to else if key of <= key of insert into 's child

16 Given: - root of a (sub) BST - a new node to insert make point to else if key of <= key of insert into 's child else insert into 's child

17 Given: - root of a (sub) BST If is EMPTY - a new node to insert else if key of <= key of insert into 's child else insert into 's child

18 To remove a node from a BST: - detach from its parent (root is special case) - if has no children: done - if has one child - attach 's parent to 's child - detach 's child - if has two children (this is more difficult) - attach 's parent to one of 's children - insert the other child (and its whole subtree) into the BST - detach 's children

19 detach from its parent - if has no children: done

20 - detach from its parent - if has one child - attach 's parent to 's child - detach 's child

21 - detach from its parent - if has two children, attach 1 to 's parent, Insert the other child into the tree - detach 's children

22 A BST can become unbalanced depending on the order that nodes are inserted. This lessens its effectiveness of fast-searching. The BST can be Balanced by reconstructing it by inserting nodes in the correct order.

23 class node { friend class BST; private: int key = 0; string data = ""; // could be more data members node * left = NULL; // ptr to left subtree (keys <=) node * right = NULL; // ptr to right subtree (keys >) };

24 class BST { // more methods could be added public: void insert(int newkey, string newdata); string search(int forkey); void print(); int height(); private: node * root = NULL; void insert(node * n, node * r); node * search(int forkey, node * r); void print(node * r); int height(node * r); };

25 // public: allocate, populate, check for empty tree void BST::insert(int newkey, string newdata) { node * n = new node; // allocate n->key = newkey; // populate n->data = newdata; if (root == NULL) // if empty tree root = n; // new node is new root else // else insert new node into insert(n, root); // entire existing tree }

26 // private: n points to new node, already allocated/populated // r points to subroot (root of a subtree, not THE root) - never NULL void BST::insert(node * n, node * r) { if (n->key <= r->key) // if new node should go on left subtree if (r->left == NULL) // if there is no left subtree yet r->left = n; // new node becomes root of left subtree else // else there is already a left subtree insert(n, r->left); // insert the new node into it. else // n->key > r->key, new node goes right if (r->right == NULL) // if there is no right subtree yet r->right = n; // new node becomes root of right subtree else // else there is already a right subtree insert(n, r->right); // insert new node into it. }

27 // public: return data of found node, or "" for not found string BST::search(int forkey) { node * p = search(forkey, ); if (p==null) return ""; else return p->data; }

28 // private: return pointer to found node, or NULL not found node * BST::search(int forkey, node * r) { if (r==null) return NULL; // not found! if (r->key == forkey) return r; // found! if (forkey <= r->key) return search(forkey, r->left); else return search(forkey, r->right); }

29 is an algorithm that "visits" all nodes of a tree in a particular order. For a, there are three orders: - In-Order - Pre-Order - Post Order

30 given -the (sub)root of a BST - Traverse 's left child - Visit - Traverse 's right child

31 given -the (sub)root of a BST - Visit - Traverse 's left child - Traverse 's right child

32 given -the (sub)root of a BST - Traverse 's left child - Traverse 's right child - Visit

33

34 void BST::print() { print(root); } // get it started void BST::print(node * r) { // prints keys sorted lowest to highest ( ) if (r==null) return; // nothing to print print(r->left); // everything <= this node cout << r->key << " "; // print this node print(r->right); // everything > this node }

35 is the number of edges (arrows) between the root and the node (height of root is 0) nodes. is the maximum of the heights of all (or: count nodes along longest path minus 1)

36 3 2

37 int BST::height() { return height(root); } // get it started int BST::height(node * r) { if (r==null) return 0; // height of empty is 0 int heightleft = height(r->left); // get height of left child int heightright = height(r->right); // get height of right child if (heightleft > heightright) // My height is the height return heightleft + 1; // of my tallest child else // plus one for me. return heightright + 1; }

38 Term Binary Search Tree (BST) root leaf parent balanced height traversal Definition a data structure that consists of a root (pointer to the first node), where each node contains a key, left child (pointer to node) and right child (pointer to node), where they keys of all nodes in the left child are less than or equal to the key of the node, and the keys of all nodes in the left child are greater than the key of the node. pointer to the first node in a BST a BST node where both children are NULL a name for a BST node in relation to its two children describes a BST with the minimum height possible for the number of nodes it contains (of a BST) the longest path from the root to any leaf an algorithm that visits (accesses/examines) all nodes of the BST.