二叉树（一）

二叉树，结合了两种数据结构的优点：一种是有序数组，一种是链表。在树中查找数据项的速度和在有序数组查找一样快；并且插入和删除数据项的速度和链表一样快。

1）在有序数组插入数据太慢：通过二分查找找到该位置，但每次所有比新数据大的坐标都要往后移动一位。不适合于频繁插入和删除数据的操作。
2）在链表查找太慢：每次查找都必须从表头开始查找，即便是有序链表也是一样。（当然有序链表通过指定值找到该链接点的速度比无序链表快一些）

树的术语：

1）路径：顺着节点的边从一个节点走到另一个节点，所经过的节点顺序排列就称为“路径”。

2）根：一棵树只有一个根，最顶端的位置，而且从根到每个节点的路径仅有一条。

3）父节点：每个节点（除了根）都有一条向上连接到另一个节点，那么上面的节点就称为“父节点”。

4）子节点：每个节点都有一条或多条向下连接到其它的节点，那么下面的节点就称为“子节点”。

5）叶节点：没有子节点的节点就称为“叶节点”。

6）子树：每个节点都可以是子树的根，它和它所有的子节点、子节点的子节点都含在子树中。一个节点的子树包含它所有的子孙。

7）访问：当程序流程到达某个节点，并进行相应的操作。就称“访问”这个节点。

8）层：一个节点的层数是从根开始到这个节点有多少代，假设根是0层，那么它的子节点是1层，再下一节点是2层。。。

9）关键字：对象中有一个数据域被指定为关键字，这个值常用来查询或其它操作。

10）二叉树：如果树中每个节点最多只有两个子节点，这样的树被称为“二叉树”。最简单也最常用的。

11）二叉搜索树：一个节点的左子节点的关键字是小于这个节点，右子结点的关键字是大于或等于这个父节点。

12）后继：在被删除的节点有两个子节点的情况下，需要拿在中序遍历中，被删的节点的下一个访问的节点替换，该替换的节点叫做被删节点的中序后继，简称后继。

public class Node {

    private Node leftChild;

    private Node rightChild;

    private int iData;

    private double dData;

    public Node(int i, double d) {
        iData = i;
        dData = d;
    }

    public int getiData() {
        return iData;
    }

    public double getdData() {
        return dData;
    }

    public Node getLeftChild() {
        return leftChild;
    }

    public void setLeftChild(Node leftChild) {
        this.leftChild = leftChild;
    }

    public Node getRightChild() {
        return rightChild;
    }

    public void setRightChild(Node rightChild) {
        this.rightChild = rightChild;
    }

    public void displayNode() {
        System.out.println("{ " + iData + " , " + dData + " }");
    }

}

public class Tree {

    private Node root;

    public boolean isEmpty() {
        return root == null;
    }

    public void insert(int i, double d) {
        Node node = new Node(i, d);
        if (isEmpty()) {
            root = node;
        }
        else {
            Node current = root;
            Node parent = null;
            while (current != null) {
                parent = current;
                if (i < current.getiData()) {
                    current = current.getLeftChild();
                }
                else {
                    current = current.getRightChild();
                }
            }
            if (i < parent.getiData()) {
                parent.setLeftChild(node);
            }
            else {
                parent.setRightChild(node);
            }
        }
    }

    public Node find(int key) {
        Node current = root;
        while (current != null) {
            if (key == current.getiData()) {
                return current;
            }
            else if (key < current.getiData()) {
                current = current.getLeftChild();
            }
            else {
                current = current.getRightChild();
            }
        }
        return null;
    }

    private void inOrder(Node localRoot) {
        if (localRoot != null) {
            inOrder(localRoot.getLeftChild());
            System.out.print("Local Node : ");
            localRoot.displayNode();
            inOrder(localRoot.getRightChild());
        }
    }

    private void preOrder(Node localRoot) {
        if (localRoot != null) {
            System.out.print("Local Node : ");
            localRoot.displayNode();
            preOrder(localRoot.getLeftChild());
            preOrder(localRoot.getRightChild());
        }
    }

    private void postOrder(Node localRoot) {
        if (localRoot != null) {
            postOrder(localRoot.getLeftChild());
            postOrder(localRoot.getRightChild());
            System.out.print("Local Node : ");
            localRoot.displayNode();
        }
    }

    //中序遍历
    public void inOrder() {
        inOrder(root);
    }

    //前序遍历
    public void preOrder() {
        preOrder(root);
    }

    //后序遍历
    public void postOrder() {
        postOrder(root);
    }

    public Node minNode() {
        Node current = root;
        Node parent = null;
        while (current != null) {
            parent = current;
            current = current.getLeftChild();
        }
        return parent;
    }

    public Node maxNode() {
        Node current = root;
        Node parent = null;
        while (current != null) {
            parent = current;
            current = current.getRightChild();
        }
        return parent;
    }

    /*
     * 删除节点需要考虑3种情况
     * 1、该节点没有子节点
     * 2、该节点只有一个子节点（用子节点替换被删掉的节点）
     * 3、该节点有两个子节点
     */
    public Node delete(int key) {
        Node current = root;
        Node parent = null;

        while (current != null) {
            if (key == current.getiData()) {
                break;
            }
            else if (key < current.getiData()) {
                parent = current;
                current = current.getLeftChild();
            }
            else {
                parent = current;
                current = current.getRightChild();
            }
        }
        if (current == null) {
            return null;
        }
        //1、该节点没有子节点
        if (current.getLeftChild() == null && current.getRightChild() == null) {
            //判断是否根节点
            if (current == root) {
                root = null;
            }
            else {
                if (key < parent.getiData()) {
                    parent.setLeftChild(null);
                }
                else {
                    parent.setRightChild(null);
                }
            }
        }
        //2、该节点只有一个子节点
        else if (current.getLeftChild() == null) {
            if (current == root) {
                root = null;
            }
            else {
                if (key < parent.getiData()) {
                    parent.setLeftChild(current.getRightChild());
                }
                else {
                    parent.setRightChild(current.getRightChild());
                }
            }
        }
        else if (current.getRightChild() == null) {
            if (current == root) {
                root = null;
            }
            else {
                if (key < parent.getiData()) {
                    parent.setLeftChild(current.getLeftChild());
                }
                else {
                    parent.setRightChild(current.getLeftChild());
                }
            }
        }
        //3、该节点有两个子节点
        else {
            Node successor = getSuccessor(current);
            if (current == root) {
                root = successor;
            }
            else {
                if (key < parent.getiData()) {
                    parent.setLeftChild(successor);
                }
                else {
                    parent.setRightChild(successor);
                }
            }
            successor.setLeftChild(current.getLeftChild());
        }
        return current;

    }

    private Node getSuccessor(Node delNode) {
        Node successorParent = delNode;
        Node successor = delNode;
        Node current = delNode.getRightChild();
        while (current != null) {
            successorParent = successor;
            successor = current;
            current = current.getLeftChild();
        }
        if (successor != delNode.getRightChild()) {
            successorParent.setLeftChild(successor.getRightChild());
            successor.setRightChild(delNode.getRightChild());
        }
        return successor;
    }

}

    public static void main(String[] args) {
        Tree tree = new Tree();
        tree.insert(50, 1.5);
        tree.insert(25, 1.6);
        tree.insert(75, 1.7);
        tree.insert(12, 1.8);
        tree.insert(37, 1.9);
        tree.insert(43, 2.0);
        tree.insert(30, 2.1);
        tree.insert(33, 2.2);
        tree.insert(87, 2.3);
        tree.insert(77, 2.4);
        tree.insert(78, 2.5);
        tree.insert(74, 2.5);
        tree.insert(90, 2.6);
        tree.insert(102, 2.7);
        tree.insert(107, 2.8);
        tree.insert(101, 2.9);
        tree.inOrder();
        System.out.println("---------------------------");
        tree.delete(12);
        tree.delete(30);
        tree.delete(87);
        tree.inOrder();
    }

打印结果：
Local Node : { 12 , 1.8 }
Local Node : { 25 , 1.6 }
Local Node : { 30 , 2.1 }
Local Node : { 33 , 2.2 }
Local Node : { 37 , 1.9 }
Local Node : { 43 , 2.0 }
Local Node : { 50 , 1.5 }
Local Node : { 74 , 2.5 }
Local Node : { 75 , 1.7 }
Local Node : { 77 , 2.4 }
Local Node : { 78 , 2.5 }
Local Node : { 87 , 2.3 }
Local Node : { 90 , 2.6 }
Local Node : { 101 , 2.9 }
Local Node : { 102 , 2.7 }
Local Node : { 107 , 2.8 }
---------------------------
Local Node : { 25 , 1.6 }
Local Node : { 33 , 2.2 }
Local Node : { 37 , 1.9 }
Local Node : { 43 , 2.0 }
Local Node : { 50 , 1.5 }
Local Node : { 74 , 2.5 }
Local Node : { 75 , 1.7 }
Local Node : { 77 , 2.4 }
Local Node : { 78 , 2.5 }
Local Node : { 90 , 2.6 }
Local Node : { 101 , 2.9 }
Local Node : { 102 , 2.7 }
Local Node : { 107 , 2.8 }