二叉树与红黑树的java实现

二叉树的java实现

public class BinaryTree {

    /**
     * 根节点
     */
    private static Node root;

    static class Node {
        int key;
        Node left, right, parent;

        public Node(int key) {
            this.key = key;
        }
    }

    public BinaryTree(int key) {
        root = new Node(key);
    }

    /**
     * 中序遍历
     * 
     * @param node 根节点
     */
    public void inOrderTreeWalk(Node node) {
        if (node != null) {
            inOrderTreeWalk(node.left);
            System.out.print(node.key + ",");
            inOrderTreeWalk(node.right);
        }
    }

    /**
     * 查找
     * 
     * @param node 根节点
     * @param key 查找值
     * @return
     */
    public Node treeSearch(Node node, int key) {
        while (node != null && key != node.key) {
            if (key < node.key) {
                node = node.left;
            } else {
                node = node.right;
            }
        }
        return node;
    }

    /**
     * 最小值
     * 
     * @param node 根节点
     * @return
     */
    public Node treeMinimum(Node node) {
        while (node.left != null) {
            node = node.left;
        }
        return node;
    }

    /**
     * 最大值
     * 
     * @param node 根节点
     * @return
     */
    public Node treeMaximum(Node node) {
        while (node.right != null) {
            node = node.right;
        }
        return node;
    }

    /**
     * 前驱
     * 
     * @param node 根节点
     * @return
     */
    public Node treePredecessor(Node node) {
        // 如果存在左子树，返回左子树的最大值
        if (node.left != null) {
            return treeMaximum(node.left);
        }
        Node y = node.parent;
        // 当不存在左子树时，返回最低祖先节点
        while (y != null && node == y.left) {
            node = y;
            y = y.parent;
        }
        return y;
    }

    /**
     * 后继
     * 
     * @param node 根节点
     * @return
     */
    public Node treeSuccessor(Node node) {
        // 如果存在右子树，返回右子树的最小值
        if (node.right != null) {
            return treeMinimum(node.right);
        }
        Node y = node.parent;
        // 当不存在右子树时，返回最低祖先节点
        while (y != null && node == y.right) {
            node = y;
            y = y.parent;
        }
        return y;
    }

    /**
     * 插入
     * 
     * @param key 插入节点的关键值
     */
    public void treeInsert(int key) {
        // 创建插入节点
        Node node = new Node(key);
        // 定义插入节点的父节点变量
        Node y = null;
        // 定义临时变量存根节点
        Node x = root;
        // 在根节点的左、右子树中查找插入位置
        while (x != null) {
            y = x;
            if (key < x.key) {
                x = x.left;
            } else {
                x = x.right;
            }
        }
        node.parent = y;
        if (y == null) {
            root = node;
        } else if (key < y.key) {
            y.left = node;
        } else {
            y.right = node;
        }
    }

    /**
     * 删除
     * 
     * @param node 删除节点
     * @return
     */
    public Node treeDelete(Node node) {
        // 定义临时变量存删除节点或后继节点
        Node y;
        // 当删除节点至多有一个孩子时
        if (node.left == null || node.right == null) {
            y = node;
        } else {// 当删除节点有两个孩子时，y存后继节点
            y = treeSuccessor(node);
        }
        // 定义临时变量存删除节点的孩子节点
        Node x;
        if (y.left != null) {
            x = y.left;
        } else {
            x = y.right;
        }
        if (x != null) {
            x.parent = y.parent;
        }
        if (y.parent == null) {
            root = x;
        } else if (y == y.parent.left) {
            y.parent.left = x;
        } else {
            y.parent.right = x;
        }
        // 当y为后继节点时，将y的关键值赋给删除节点
        if (y != node) {
            node.key = y.key;
        }
        return y;
    }

}

 红黑树的java实现（备注：中序遍历、查找、最大、最小、前驱、后继与二叉树基本一致）

public class RBTree {

    /**
     * 根节点
     */
    private static Node root;

    /**
     * nil节点是红黑树的叶子节点不同于二叉树的叶子节点
     * 颜色为黑色，key、left、right、parent可以是任意允许的值
     * 这里key设置为0，left、right、parent为null
     */
    private Node nil = new Node(true);

    static class Node {
        int key;
        Node left, right, parent;
        boolean color;// true黑，false红

        public Node(int key) {
            this.key = key;
        }

        public Node(boolean color) {
            this.color = color;
        }

        public boolean equals(Node node) {
            return this.key == node.key;
        }
    }

    public RBTree(int key) {
        root = new Node(key);
    }

    /**
     * 中序遍历
     * 
     * @param node 根节点
     */
    public void inOrderTreeWalk(Node node) {
        if (node != null && !node.equals(nil)) {
            inOrderTreeWalk(node.left);
            System.out.print((node.color == true ? "黑" : "红") + node.key + ",");
            inOrderTreeWalk(node.right);
        }
    }

    /**
     * 查找
     * 
     * @param node 根节点
     * @param key 查找值
     * @return
     */
    public Node treeSearch(Node node, int key) {
        while (node != null && key != node.key) {
            if (key < node.key) {
                node = node.left;
            } else {
                node = node.right;
            }
        }
        return node;
    }

    /**
     * 最小值
     * 
     * @param node 根节点
     * @return
     */
    public Node treeMinimum(Node node) {
        while (node.left != null) {
            node = node.left;
        }
        return node;
    }

    /**
     * 最大值
     * 
     * @param node 根节点
     * @return
     */
    public Node treeMaximum(Node node) {
        while (node.right != null) {
            node = node.right;
        }
        return node;
    }

    /**
     * 前驱
     * 
     * @param node 根节点
     * @return
     */
    public Node treePredecessor(Node node) {
        // 如果存在左子树，返回左子树的最大值
        if (node.left != null) {
            return treeMaximum(node.left);
        }
        Node y = node.parent;
        // 当不存在左子树时，返回最低祖先节点
        while (y != null && node == y.left) {
            node = y;
            y = y.parent;
        }
        return y;
    }

    /**
     * 后继
     * 
     * @param node 根节点
     * @return
     */
    public Node treeSuccessor(Node node) {
        // 如果存在右子树，返回右子树的最小值
        if (node.right != null) {
            return treeMinimum(node.right);
        }
        Node y = node.parent;
        // 当不存在右子树时，返回最低祖先节点
        while (y != null && node == y.right) {
            node = y;
            y = y.parent;
        }
        return y;
    }

    /**
     * 左旋（node节点必有右孩子）
     * 
     * @param node 
     */
    public void leftTotate(Node node) {
        Node y = node.right;
        node.right = y.left;
        if (y.left != null)
            y.left.parent = node;
        y.parent = node.parent;
        if (node.parent == null) {
            root = y;
        } else if (node == node.parent.left) {
            node.parent.left = y;
        } else {
            node.parent.right = y;
        }
        node.parent = y;
        y.left = node;
    }

    /**
     * 右旋（node节点必有左孩子）
     * 
     * @param node
     */
    public void rightTotate(Node node) {
        Node y = node.left;
        node.left = y.right;
        if (y.right != null)
            y.right.parent = node;
        y.parent = node.parent;
        if (node.parent == null) {
            root = y;
        } else if (node == node.parent.left) {
            node.parent.left = y;
        } else {
            node.parent.right = y;
        }
        node.parent = y;
        y.right = node;
    }

    /**
     * 插入
     * 
     * @param key 插入节点的关键值
     */
    public void RBTreeInsert(int key) {
        // 创建插入节点
        Node node = new Node(key);
        // 定义插入节点的父节点变量
        Node y = null;
        // 定义临时变量存根节点
        Node x = root;
        // 在根节点的左、右子树中查找插入位置
        while (x != null) {
            y = x;
            if (key < x.key) {
                x = x.left;
            } else {
                x = x.right;
            }
        }
        node.parent = y;
        if (y == null) {
            root = node;
        } else if (key < y.key) {
            y.left = node;
        } else {
            y.right = node;
        }
        RBTreeInsertFixup(node);
    }

    /**
     * 插入后修复
     * 
     * @param node 插入节点
     */
    public void RBTreeInsertFixup(Node node) {
        // 当插入节点的父节点为红色时，执行循环
        while (node.parent != null && !node.parent.color && node.parent.parent != null) {
            // 当插入节点的父节点为其爷爷节点的左孩子时
            if (node.parent == node.parent.parent.left) {
                // 定义y存叔叔节点
                Node y = node.parent.parent.right;
                // 如果叔叔节点为红色，将父节点与叔叔节点变成黑色，爷爷节点变成红色，将插入节点升级为爷爷节点
                if (y != null && !y.color) {
                    node.parent.color = true;
                    y.color = true;
                    node.parent.parent.color = false;
                    node = node.parent.parent;
                } else if (node == node.parent.right) {//如果叔叔节点为黑色，插入节点是父节点的右孩子，将插入节点升级为父节点，左旋插入节点
                    node = node.parent;
                    leftTotate(node);
                } else {//如果叔叔节点为黑色，插入节点是父节点的左孩子，将父节点变成黑色，爷爷节点变成红色，右旋爷爷节点
                    node.parent.color = true;
                    node.parent.parent.color = false;
                    rightTotate(node.parent.parent);
                }
            } else {// 当插入节点的父节点为其爷爷节点的右孩子时
                // 定义y存叔叔节点
                Node y = node.parent.parent.left;
                // 如果叔叔节点为红色，将父节点与叔叔节点变成黑色，爷爷节点变成红色，将插入节点升级为爷爷节点
                if (y != null && !y.color) {
                    node.parent.color = true;
                    y.color = true;
                    node.parent.parent.color = false;
                    node = node.parent.parent;
                } else if (node == node.parent.left) {//如果叔叔节点为黑色，插入节点是父节点的左孩子，将插入节点升级为父节点，右旋插入节点
                    node = node.parent;
                    rightTotate(node);
                } else {//如果叔叔节点为黑色，插入节点是父节点的右孩子，将父节点变成黑色，爷爷节点变成红色，左旋爷爷节点
                    node.parent.color = true;
                    node.parent.parent.color = false;
                    leftTotate(node.parent.parent);
                }
            }
        }
        // 将根节点变成黑色
        if (root.parent != null) {
            root = root.parent;
        }
        root.color = true;
    }

    /**
     * 删除
     * 
     * @param node 删除节点
     * @return
     */
    public Node RBTreeDelete(Node node) {
        // 定义临时变量存删除节点或后继节点
        Node y;
        // 当删除节点至多有一个孩子时
        if (node.left == null || node.right == null) {
            y = node;
        } else {// 当删除节点有两个孩子时，y存后继节点
            y = treeSuccessor(node);
        }
        // 定义临时变量存删除节点的孩子节点
        Node x;
        if (y.left != null) {
            x = y.left;
        } else {
            x = y.right;
        }
        if (x != null) {
            x.parent = y.parent;
        } else {
            x = nil;
            x.parent = y.parent;
        }
        if (y.parent == null) {
            root = x;
        } else if (y == y.parent.left) {
            y.parent.left = x;
        } else {
            y.parent.right = x;
        }
        // 当y为后继节点时，将y的关键值赋给删除节点
        if (y != node) {
            node.key = y.key;
        }
        // 当y为黑色时，需要修复红黑树
        if (y.color) {
            RBTreeDeleteFixup(x);
        }
        return y;
    }

    /**
     * 删除后修复
     * 
     * @param node 删除节点的孩子节点
     */
    public void RBTreeDeleteFixup(Node node) {
        // 当node不等于根节点并且为黑色时，执行循环
        while (node != root && (node == nil || node.color)) {
            // 如果node节点为父节点的左孩子
            if (node == node.parent.left) {
                // 定义w存兄弟节点
                Node w = node.parent.right;
                // 当兄弟节点为红色时，将兄弟节点变成黑色，父节点变成红色，左旋父节点，更新兄弟节点
                if (!w.color) {
                    w.color = true;
                    node.parent.color = false;
                    leftTotate(node.parent);
                    w = node.parent.right;
                } else if (w.left.color && w.right.color) {//当兄弟节点为黑色且其两个孩子都为黑色时，将兄弟节点变成红色，将node节点升级为父节点
                    w.color = false;
                    node = node.parent;
                } else if (w.right.color) {//当兄弟节点为黑色且其左孩子为红色、其右孩子为黑色时，将其左孩子变成黑色、兄弟节点变成红色，右旋兄弟节点，更新兄弟节点
                    w.left.color = true;
                    w.color = false;
                    rightTotate(w);
                    w = node.parent.right;
                } else {//当兄弟节点为黑色且其右孩子为红色时，将父节点的颜色赋给兄弟节点，父节点变成黑色，兄弟节点的右孩子变成黑色，左旋父节点
                    w.color = node.parent.color;
                    node.parent.color = true;
                    w.right.color = true;
                    leftTotate(node.parent);
                    // 将根节点赋给node
                    if (root.parent != null) {
                        root = root.parent;
                    }
                    node = root;
                }
            } else {// 如果node节点为父节点的右孩子
                // 定义w存兄弟节点
                Node w = node.parent.left;
                // 当兄弟节点为红色时，将兄弟节点变成黑色，父节点变成红色，右旋父节点，更新兄弟节点
                if (!w.color) {
                    w.color = true;
                    node.parent.color = false;
                    rightTotate(node.parent);
                    w = node.parent.left;
                } else if (w.left.color && w.right.color) {//当兄弟节点为黑色且其两个孩子都为黑色时，将兄弟节点变成红色，将node节点升级为父节点
                    w.color = false;
                    node = node.parent;
                } else if (w.left.color) {//当兄弟节点为黑色且其左孩子为黑色、其右孩子为红色时，将其右孩子变成黑色、兄弟节点变成红色，左旋兄弟节点，更新兄弟节点
                    w.right.color = true;
                    w.color = false;
                    leftTotate(w);
                    w = node.parent.left;
                } else {//当兄弟节点为黑色且其左孩子为红色时，将父节点的颜色赋给兄弟节点，父节点变成黑色，兄弟节点的左孩子变成黑色，右旋父节点
                    w.color = node.parent.color;
                    node.parent.color = true;
                    w.left.color = true;
                    rightTotate(node.parent);
                    // 将根节点赋给node
                    if (root.parent != null) {
                        root = root.parent;
                    }
                    node = root;
                }
            }
        }
        // 将node节点变成黑色
        node.color = true;
    }

    public static void main(String[] args) {
        int[] arr = { 21, 3, 6, 7, 12, 25, 17, 8, 15 };
        RBTree rb = new RBTree(21);
        for (int i = 1; i < arr.length; i++) {
            rb.RBTreeInsert(arr[i]);
        }
        rb.inOrderTreeWalk(root);
        rb.RBTreeDelete(rb.treeSearch(root, 21));
        System.out.println();
        rb.inOrderTreeWalk(root);
    }

}