红黑树的简单实现

红黑树的简单实现：

定义红黑树的结构

package com.zzu.arth;

public class TreeNode {
    private Integer value;
    private String color = "red";
    private TreeNode left;
    private TreeNode right;
    private TreeNode parent;

    public TreeNode() {

    }
    public TreeNode(Integer value, String color, TreeNode left, TreeNode right, TreeNode parent) {
        this.value = value;
        this.color = color;
        this.left = left;
        this.right = right;
        this.parent = parent;
    }

    public TreeNode(Integer value) {
        this.value = value;
    }

    public TreeNode(Integer value, TreeNode left, TreeNode right, TreeNode parent) {
        this.value = value;
        this.left = left;
        this.right = right;
        this.parent = parent;
    }

    public Integer getValue() {
        return value;
    }

    public void setValue(Integer value) {
        this.value = value;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public TreeNode getLeft() {
        return left;
    }

    public void setLeft(TreeNode left) {
        this.left = left;
    }

    public TreeNode getRight() {
        return right;
    }

    public void setRight(TreeNode right) {
        this.right = right;
    }

    public TreeNode getParent() {
        return parent;
    }

    public void setParent(TreeNode parent) {
        this.parent = parent;
    }
}

对新插入的节点进行调整

public static void ajustTree(TreeNode root) {
        if(root == null) {
            return;
        }
        //如果有两个红色的节点相连
       if(root.getColor().equals("red") && root.getParent() != null && root.getParent().getColor().equals("red")) {
            //如果该节点的爷爷节点有两个孩子且都为红色
           TreeNode grandParent = root.getParent().getParent();
           if(grandParent == null) {
               root.getParent().setColor("black");
               return;
           }
           TreeNode left = grandParent.getLeft();
           TreeNode right = grandParent.getRight();
           boolean exist = grandParent != null && left != null && right != null;
           if(exist && left.getColor().equals("red") && right.getColor().equals("red")) {
               //设置祖父节点为红色，双子节点为黑色
                grandParent.setColor("red");
                left.setColor("black");
                right.setColor("black");
                //以祖父节点向上调节
               if(grandParent.getParent() == null) {//如果到达了根节点，设置根节点为黑色
                   grandParent.setColor("black");
                   return;
               } else {
                   ajustTree(grandParent);
               }
           } else {
               if(grandParent == null) {
                   root.getParent().setColor("black");
                   return;
               }
               if(grandParent != null && left != null && left.getLeft() == root) {//LL型
                   TreeNode ggrand = grandParent.getParent();
                   TreeNode temp = left.getRight();
                   left.setRight(grandParent);
                   grandParent.setParent(left);
                   grandParent.setLeft(temp);
                   if(temp != null) {
                       temp.setParent(grandParent);
                   }
                   if(ggrand != null && ggrand.getLeft() == grandParent) {
                       ggrand.setLeft(left);
                   } else if(ggrand != null && ggrand.getRight() == grandParent) {
                     ggrand.setRight(left);
                   }
                   left.setParent(ggrand);
                   left.getLeft().setColor("red");
                   left.getRight().setColor("red");
                   left.setColor("black");
                   ajustTree(left);
               } else if(grandParent != null && left != null && left.getRight() == root) {//LR型
                   //首先把其变成LL型
                    TreeNode ggrand = grandParent.getParent();

                    left.setRight(root.getLeft());
                    if(root.getLeft() != null) {
                        root.getLeft().setParent(left);
                    }
                    root.setLeft(left);
                    left.setParent(root);
                    grandParent.setLeft(root);
                    root.setParent(grandParent);

                    grandParent.setLeft(root.getRight());
                    if(root.getRight() != null) {
                        root.getRight().setParent(grandParent);
                    }
                    root.setRight(grandParent);
                    grandParent.setParent(root);

                    if(ggrand != null && ggrand.getLeft() == grandParent) {
                        ggrand.setLeft(root);
                    } else if(ggrand != null && ggrand.getRight() == grandParent) {
                        ggrand.setRight(root);
                    }
                    root.setParent(ggrand);
                   root.getLeft().setColor("red");
                   root.getRight().setColor("red");
                   root.setColor("black");
                   ajustTree(root);
               } else if(grandParent != null && right != null && right.getRight() == root) {//RR
                   TreeNode ggrand = grandParent.getParent();
                   //调整树型
                   TreeNode temp = right.getLeft();
                   grandParent.setRight(temp);
                   if(temp != null) {
                       temp.setParent(grandParent);
                   }
                   right.setLeft(grandParent);
                   grandParent.setParent(right);
                   if(ggrand != null && ggrand.getLeft() == grandParent) {
                       ggrand.setLeft(right);
                   } else if(ggrand != null && ggrand.getRight() == grandParent) {
                       ggrand.setRight(right);
                   }
                   right.setParent(ggrand);
                   right.getLeft().setColor("red");
                   right.getRight().setColor("red");
                   right.setColor("black");
                   ajustTree(right);
               } else if(grandParent != null && right != null && right.getLeft() == root) {//RL
                   //调整树形
                   TreeNode ggrand = grandParent.getParent();
                   TreeNode temp = root.getRight();
                   right.setLeft(temp);
                   if(temp != null) {
                       temp.setParent(right);
                   }
                   root.setRight(right);
                   right.setParent(root);
                   grandParent.setRight(root.getLeft());
                   root.getLeft().setParent(grandParent);
                   root.setLeft(grandParent);
                   grandParent.setParent(root);
                   if(ggrand != null && ggrand.getLeft() == grandParent) {
                       ggrand.setLeft(root);
                   }else if(ggrand != null && ggrand.getRight() == grandParent) {
                       ggrand.setRight(root);
                   }
                   root.setParent(ggrand);
                   root.getLeft().setColor("red");
                   root.getRight().setColor("red");
                   root.setColor("black");
                   ajustTree(root);
               }
           }
       }
    }

插入节点的方法

 public static boolean insert(TreeNode root,TreeNode insetNode) {
        if(insetNode == null) {
            return false;
        }
        if(root == null) {
            BlackRedTree.root = insetNode;
            return true;
        }
        int com = root.getValue().compareTo(insetNode.getValue());
        if(root.getLeft() == null && com > 0) {
            root.setLeft(insetNode);
            insetNode.setParent(root);
            return true;
        } else if(root.getRight() == null && com < 0) {
            root.setRight(insetNode);
            insetNode.setParent(root);
            return true;
        }

        if(com == 0) {
            return false;
        } else if(com > 0) {
            return insert(root.getLeft(),insetNode);
        } else {
            return insert(root.getRight(),insetNode);
        }

    }

这里需要注意的是：由于每次插入新的节点后，会对红黑树进行调整，那么树的根节点就可能会发生改变，因此在每一次插入之前需要先找到树的根节点。

参考原理：https://blog.csdn.net/F13253524870/article/details/117618380