1. Tree

2. Why Use Binary Trees?
It combines the advantages of two other structures: an ordered array and a linked list.
You can search a tree quickly, as you can an ordered array, and you can also insert and delete items quickly, as you can with a linked list.
you can quickly search such an array for a particular value, using a binary search.
insertions and deletions are quick to perform on a linked list. They are accomplished simply by changing a few references

3. What Is a Tree? A tree consists of nodes connected by edges
In computer programs, nodes often represent such entities as people, car parts, airline reservations, and so on
The lines (edges) between the nodes represent the way the nodes are related

4. Tree Terminology
similar to real-world trees or to family relationships (as in parents and children),

5. Tree Terminology (con’t)
Path
Think of someone walking from node to node along the edges that connect them.
Root
The node at the top of the tree is called the root. There is only one root in a tree.
For a collection of nodes and edges to be defined as a tree, there must be one (and only one!) path from the root to any other node.

6. Tree Terminology (con’t)
Parent
Any node (except the root) has exactly one edge running upward to another node.
The node above it is called the parent of the node.
Child
Any node may have one or more lines running downward to other nodes. These nodes below a given node are called its children.
Leaf
A node that has no children is called a leaf node or simply a leaf. There can be only one root in a tree, but there can be many leaves.

7. Tree Terminology (con’t)
Subtree
Any node may be considered to be the root of a subtree, which consists of its children, and its children’s children, and so on.
If you think in terms of families, a node’s subtree contains all its descendants.
Visiting
A node is visited when program control arrives at the node, usually for the purpose of carrying out some operation on the node, such as checking the value of one of its data fields or displaying it.
Merely passing over a node on the path from one node to another is not considered to be visiting the node.
Traversing
To traverse a tree means to visit all the nodes in some specified order.
For example, you might visit all the nodes in order of ascending key value.

8. Tree Terminology (con’t)
Levels
The level of a particular node refers to how many generations the node is from the root.
If we assume the root is Level 0, then its children will be Level 1, its grandchildren will be Level 2, and so on.
Keys
One data field in an object is usually designated a key value. This value is used to search for the item or perform other operations on it.
In tree diagrams, when a circle represents a node holding a data item, the key value of the item is typically shown in the circle.

9. Binary Trees
If every node in a tree can have at most two children, the tree is called a binary tree
The two children of each node in a binary tree are called the left child and the right child
The defining characteristic of a binary search tree is this: A node’s left child must have a key less than its parent, and a node’s right child must have a key greater than or equal to its parent.

10. The Node Class
Node objects contain the data representing the objects being stored (employees in an employee database, for example) and also references to each of the node’s two children.

11. Finding a Node

12. Inserting a Node
To insert a node, we must first find the place to insert it
Let’s assume we’re going to insert a new node with the value 45
The value 45 is less than 60 but greater than 40, so we arrive at node 50. Now we want to go left because 45 is less than 50, but 50 has no left child; its leftChild fieldis null.
When it sees this null, the insertion routine has found the place to attach the new node

13. Inserting a Node (con’t)

14. Traversing the Tree Inorder Traversal
An inorder traversal of a binary search tree will cause all the nodes to be visited in ascending order, based on their key values.
The method needs to do only three things:
1. Call itself to traverse the node’s left subtree.
2. Visit the node.
3. Call itself to traverse the node’s right subtree.
Remember that visiting a node means doing something to it: displaying it, writing it to a file, or whatever.

15. Traversing the Tree (con’t)

16. Traversing the Tree (con’t)

17. Finding Maximum and Minimum Values
For the minimum, go to the left child of the root; then go to the left child of that child, and so on, until you come to a node that has no left child. This node is the minimum
For the maximum value in the tree, follow the same procedure, but go from right child to right child until you find a node with no right child. This node is the maximum.
The code is the same except that the last statement in the loop is
current = current.rightChild;
// go to right child

18. Deleting a Node
You start by finding the node you want to delete, using the same approach we saw in find() and insert().
When you’ve found the node, there are three cases to consider:
1. The node to be deleted is a leaf (has no children).
2. The node to be deleted has one child.
3. The node to be deleted has two children.

20. Case 1: The Node to Be Deleted Has No Children
After we’ve found the node, we check first to verify that it has no children.
When this is true, we check the special case of the root. If that’s the node to be deleted, we simply set it to null; this empties the tree.
Otherwise, we set the parent’s leftChild or rightChild field to null to disconnect the parent from the node.

21. Case 2: The Node to Be Deleted Has One Child
There are four variations:
The child of the node to be deleted may be either a left or right child,
and for each of these cases the node to be deleted may be either the left or right child of its parent.
There is also a specialized situation: the node to be deleted may be the root, in which case it has no parent and is simply replaced by the appropriate subtree

22. Case 2: The Node to Be Deleted Has One Child

23. Case 3: The Node to Be Deleted Has Two Children
To delete a node with two children, replace the node with its inorder successor.
For each node, the node with the next-highest key is called its inorder successor, or simply its successor.

24. Finding the Successor
First, the program goes to the original node’s right child, which must have a key larger than the node.
Then it goes to this right child’s left child (if it has one), and to this left child’s left child, and so on, following down the path of left children.
The last left child in this path is the successor of the original node

25. Why does this algorithm work?
What we’re really looking for is the smallest of the set of nodes that are larger than the original node
If the right child of the original node has no left children, this right child is itself the successor

26. Java Code to Find the Successor

27. Successor Is Right Child of delNode
If successor is the right child of current, things are simplified somewhat. This operation requires only two steps:
Unplug current from the rightChild field of its parent (or leftChild field if appropriate), and set this field to point to successor.
Unplug current’s left child from current, and plug it into the leftChild field of Successor.

28. Successor Is Left Descendant of Right Child of delNode
Plug the right child of successor into the leftChild field of the successor’s parent.
Plug the right child of the node to be deleted into the rightChild field of successor.
Unplug current from the rightChild field of its parent, and set this field to point to successor.
Unplug current’s left child from current, and plug it into the leftChild field of successor
Steps 1 and 2 are handled in the getSuccessor() routine, while 3 and 4 are carried out in delete()

29. Successor Is Left Descendant of Right Child of delNode (con’t)

31. The Complete Delete Method

32. The Complete Delete Method