二叉查找树

二叉排序树（Binary Sort Tree）又称二叉查找树（Binary Search Tree），亦称二叉搜索树。二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：
（1）若左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值；
（2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；
（3）左、右子树也分别为二叉排序树；
如下图所示：

1、查询二叉查找树

查找30的查找顺序为50-20-30

2、二叉查找树插入
首先执行查找算法，找出被插结点的父亲结点。判断被插结点是其父亲结点的左、右儿子。将被插结点作为叶子结点插入。若二叉树为空。则首先单独生成根结点。
注意：新插入的结点总是叶子结点。

3、二叉查找树删除

删除分为三种情况
1）删除的节点为叶子节点：直接删除即可

2）删除的节点只有左子树或者只有右子树：将节点的子树上移一层即可

3）删除的节点既有右子树也有左子树：找到需要删除的结点p的直接前驱（或直接后继）s，用s来替换结点p，然后再删除此结点s
注意：这里的前驱和后继是指中序遍历时的顺序。

Java代码

public class IntBinaryTree {    private static final boolean CHECK_INVARIANT = true;    private Node root;    private int size;    public int size() {        return size;    }    public boolean isEmpty() {        return size == 0;    }    private Node minimumNode(Node node) {        assert node != null;        while (node.left != null) {            node = node.left;        }        return node;    }    public int minimum() {        if (size == 0) throw new IllegalStateException("no data");        return minimumNode(root).data;    }    private Node maximumNode(Node node) {        assert node != null;        while (node.right != null) {            node = node.right;        }        return node;    }    public int maximum() {        if (size == 0) throw new IllegalStateException("no data");        return maximumNode(root).data;    }    private Node successorNode(Node node) {        assert node != null;        if (node.right != null) {            return minimumNode(node.right);        } else {            Node parent = node.parent;            while (parent != null && parent.right == node) {                node = parent;                parent = node.parent;            }            return parent;        }    }    public IntIterator ascendingIterator() {        return new IntIterator() {            private Node next = root == null ? null : minimumNode(root);            public boolean hasNext() {                return next != null;            }            public int next() {                if (next == null) throw new NoSuchElementException();                int result = next.data;                next = successorNode(next);                return result;            }        };    }    private Node predecessorNode(Node node) {        assert node != null;        if (node.left != null) {            return maximumNode(node.left);        } else {            Node parent = node.parent;            while (parent != null && parent.left == node) {                node = parent;                parent = node.parent;            }            return parent;        }    }    public IntIterator desendingIterator() {        return new IntIterator() {            private Node next = root == null ? null : maximumNode(root);            public boolean hasNext() {                return next != null;            }            public int next() {                if (next == null) throw new NoSuchElementException();                int result = next.data;                next = predecessorNode(next);                return result;            }        };    }    Node searchNode(int d) {        return searchNode(root, d);    }    private Node searchNode(Node node, int d) {        while (node != null && node.data != d) {            if (d < node.data) node = node.left;            else node = node.right;        }        return node;    }    public void insert(int d) {         Node prev = null;         Node cur = root;         while (cur != null) {             prev = cur;             if (d < cur.data) {                 cur = cur.left;             } else {                 cur = cur.right;             }         }         if (prev == null) {                 root = new Node(d);         } else {             Node newNode = new Node(d, prev);             if (d < prev.data) {                 prev.left = newNode;             } else {                 prev.right = newNode;             }         }         size++;         if (CHECK_INVARIANT) checkInvarient();    }    public boolean delete(int d) {        Node node = searchNode(d);        if (node != null) {            delete(node);            if (CHECK_INVARIANT) checkInvarient();            return true;        } else {            return false;        }    }    private void delete(Node node) {        assert node != null;        Node d; // d为要删除的结点        if (node.left == null || node.right == null) {            d = node;        } else {            d = successorNode(node);        }        Node c = d.left != null ? d.left : d.right; // c为要链接到的子结点        if (c != null) c.parent = d.parent;        if (d.parent == null) {            root = c;        } else {            if (d.parent.left == d) {                d.parent.left = c;            } else {                d.parent.right = c;            }        }        if (d != node) {            node.data = d.data;        }        size--;    }    private void checkInvarient() {        IdentityHashMap<Node, Node> set = new IdentityHashMap<Node, Node>();        checkLeftRightParentPointer(root, set);        if (set.size() != size) {            throw new IllegalStateException(String.format("actual size(%d) is not the expected size(%d)", set.size(), size));        }    }    /**     * 检查left, right, parent指针之间的引用关系是否正确。     */    private void checkLeftRightParentPointer(Node node, IdentityHashMap<Node, Node> set) {        if (node == null) return;        if (set.containsKey(node)) {            throw new IllegalStateException("circular reference detected!");        }        set.put(node, node);        Node l = node.left; Node r = node.right;        if (l != null) {             if (l.parent != node) {                 throw new IllegalStateException("left-parent relation violated");             }             if (l.data > node.data) {                 throw new IllegalStateException(String.format("left node(%s) > parent node(%s)", l, node));             }        }        if (r != null) {            if (r.parent != node) {                throw new IllegalStateException("right-parent relation violated");            }             if (r.data < node.data) {                 throw new IllegalStateException(String.format("right node(%s) < parent node(%s)", r, node));             }        }        checkLeftRightParentPointer(node.left, set);        checkLeftRightParentPointer(node.right, set);    }    public String toString() {        if (root == null) return "[empty]";        StringBuilder sb = new StringBuilder();        Node node = minimumNode(root);        while (node != null) {            sb.append(String.format("%d: %s %s %s%n", node.data,                    node.left == null ? "-" : node.left.data,                    node.right == null ? "-" : node.right.data,                    node.parent == null ? "-" : node.parent.data));            node = successorNode(node);        }        return sb.toString();    }    private static class Node {        private int data;        private Node left;        private Node right;        private Node parent;        public Node(int d) { data = d; }        public Node(int d, Node p) { data = d; parent = p; }        public Node(int d, Node p, Node l, Node r) {            data = d; parent = p; left = l; right = r;        }        public String toString() { return Integer.toString(data); }    }    public static void main(String[] args) {        IntBinaryTree btree = new IntBinaryTree();        int[] data = new int[] { 8, 9, 6, 5, 13, 7};        for (int i = 0; i < data.length; i++) {            btree.insert(data[i]);        }        System.out.println("tree: " + btree);        System.out.println("minimum: " + btree.minimum());        System.out.println("maximum: " + btree.maximum());        System.out.println("ascendingIterator");        for (IntIterator itor = btree.ascendingIterator(); itor.hasNext();) {            System.out.println(itor.next());        }        System.out.println("desendingIterator");        for (IntIterator itor = btree.desendingIterator(); itor.hasNext();) {            System.out.println(itor.next());        }        btree.delete(6);        System.out.println("ascendingIterator");        for (IntIterator itor = btree.ascendingIterator(); itor.hasNext();) {            System.out.println(itor.next());        }        btree = new IntBinaryTree();        Random random = new Random();        for (int i = 0; i < 100; i++) {            btree.insert(random.nextInt(200));        }        for (int i = 0; i < 200; i++) {            btree.delete(random.nextInt(200));        }    }}