二叉树及其基本操作

二叉查找树（Binary Search Tree），或者是一棵空树，或者是具有下列性质的二叉树：

1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
2. 若它的右子树不空，则右子树上所有结点的值均大于或者等于它的根结点的值；
3. 它的左、右子树也分别为二叉排序树。
   
   

二叉查找树的表示：

class Node {    int data;    Node leftChild = null;    Node rightChild = null;}

二叉查找树的常用方法：

1. 查找(lookup)

/*Given a binary tree, return true if a node with the target data is found in the tree. Recurs down the tree, chooses the left or right branch by comparing the target to each node.*/static boolean lookup(Node rootNode, int target) {    // 1. Base case == empty tree    // in that case, the target is not found so return false    if (rootNode == null) return false;    else if (target == rootNode.data) return true;    else if (target < rootNode.data) return(lookup(rootNode.leftChild, target));    else return(lookup(rootNode.rightChild, target));}

2. 最大（max）

/*return the node with maximum key value. It should be last right child of the tree, or the root if the root does not have any child*/public Node maxNode(Node rootNode) {while (rootNode.righttChild != null) {rootNode = rootNode.rightChild;}return rootNode;}

3. 最小 （min）

/*return the node with minimum key value. It should be last left child of the tree, or the root if the root does not have any child*/public Node minNode(Node rootNode) {while (rootNode.leftChild != null) {rootNode = rootNode.leftChild;}return rootNode;}

4. 插入（insert）

public static Node insert(Node root, int data) {// 1. If the tree is empty, the new node is the rootif (root == null) {return new Node(data);}else {// 2. Otherwise, recur down the treeif (data <= root.data) root.leftChild = insert(root.leftChild, data);else root.rightChild = insert(root.rightChild, data);}return root;}

5. in-order tree walk

public void inorder(Node rootNode) {if (rootNode != null) {inorder(rootNode.leftChild);print(nodeNode.data);inorder(rootNode.rightChild);}}

6. successor and predecessor

一个node的successor可以通过in-order walk看出来，因为in-order walk实际上是把二叉查找树做了一个排序。 predecesor 刚好和successor 相反。

Search consists of two cases.

1） If node x has a non-empty right subtree, then x’s successor is the minimum in the right subtree of x.

2） If node x has an empty right subtree, then as long as we move to the left up the tree (move up through right children), we are visiting smaller keys. x’s successor y is the node that x is the predecessor of (x is the maximum in y’s left subtree). In other words, x’s successor y, is the lowest ancestor of x whose left child is also an ancestor of x.

public Node Successor(Node node) {if (node.rightChild != null) {return minNode(node.rightChild);}Node parentNode = node.parent;while (parentNode != null && node == parentNode.rightChild) {node = parentNode;parentNode = parentNode.parent;}return parentNode;}

If node has two children, its predecessor is the maximum value in its left subtree. If it does not have a left child a node's predecessor is its first left ancestor.

7.  删除 （delete）

删除一个node x 需要考虑下面几种情况：

case 1: if x has no children,  then remove x;

case 2: if x has one child, then make p[x] point to child;

case 3: if x has two children (subtrees) , then swap x with its successor, perform case 0 or case 1 to delete it.

伪代码：

delete(x)    if x.left = NIL and x.right = NIL //case 1        if x.parent.left = x           x.parent.left = NIL        else           x.parent.right = NIL    else if x.left = NIL //case 2a            connect x.parent to x.right    else if x.right = NIL //case 2b            connect x.parent to x.left    else //case 3            y = successor(x)        connect y.parent to y.right            replace x with y

8. 求节点的个数（size）

/*Compute the number of nodes in a tree.*/int size(Node rootNode) {      if (node == NULL) {      return(0);      } else {             return(size(rootNode.leftChild) + 1 + size(rootNode.rightChild));      }}

http://blog.csdn.net/beiyetengqing