Java 实现二叉树排列删除

二叉树

1.创建节点

// 创建节点
class Node {
    int value;
    Node left;
    Node right;
​
    public Node(int value) {
        this.value = value;
    }
}

2.添加节点

先赋值root节点，接着调用root.add(node)方法，判断传入的节点值，如果需要添加的值是否比当前节点的值要小，若条件成立再判断当前节点的左子树是否为空，如果为空，把传入的值赋给当前节点的左子树，如果不为空使用递归的方法，向左子树添加。如果需要添加的值比当前节点的值要大，反过来即可。

public void add(Node node) {
    if (node == null) {
        return;
    }
    // 判断传入的节点值
    if (node.value < this.value) { // 添加的值<当前节点的值
        if (this.left == null) { //左子树为空
            this.left = node;
        } else { // 左子树不为空：递归向左子树添加
            this.left.add(node);
        }
    } else { // 添加的值>当前节点的值
        if (this.right == null) {
            this.right = node;
        } else {
            //递归向右子树添加
            this.right.add(node);
        }
    }
}

创建class BinarySortTree调用add方法

class BinarySortTree {
    private Node root;
    
    public void add(Node node) {
        if (root == null) {
            root = node;
        } else {
            root.add(node);
        }
    }
}

2.遍历

2.1前序遍历

前序遍历：先输出父节点，再遍历左子树和右子树。

前序遍历的结果：M，G，D，B，A，C，F，E，J，H，I，K，L，S，P，O，N，Q，R，W，U，T，V，X，Z，Y
在Node.class中创建preOrder()方法，实现先序遍历。

public void preOrder() {
    System.out.println(this);
    if (this.left != null) {
        this.left.preOrder();
    }
    if (this.right != null) {
        this.right.preOrder();
    }
}

在BinarySortTree中调用perOrder()方法。

public void perOrder() {
    if (root != null) {
        root.preOrder();
    } else {
        System.out.println("root为空!!!");
    }
}

2.2中序遍历

中序遍历：先遍历左子树，再输出父节点，再遍历右子树。

中序遍历的结果：A，B，C，D，E，F，G，H，I，J，K，L，M，N，O，P，Q，R，S，T，U，V，W，X，Y，Z
在Node.class中创建infixOrder()方法，实现中序遍历。

public void infixOrder() {
    if (this.left != null) {
        this.left.infixOrder();
    }
    System.out.println(this);
    if (this.right != null) {
        this.right.infixOrder();
    }
}

在BinarySortTree中调用infixOrder()方法。

public void infixOrder() {
    if (root != null) {
        root.infixOrder();
    } else {
        System.out.println("root为空!!!");
    }
}

2.3后序遍历

后序遍历：先遍历左子树，再遍历右子树，再遍历父节点。

后序遍历的结果：A，C，B，E，F，D，I，H，L，K，J，G，N，O，R，Q，P，T，V，U，Y，Z，X，W，S，M
在Node.class中创建postOrder()方法，实现中序遍历。

 public void postOrder() {
        if (this.left != null) {
            this.left.postOrder();
        }
        if (this.right != null) {
            this.right.postOrder();
        }
        System.out.println(this);
    }

在BinarySortTree中调用postOrder()方法。

public void postOrder() {
    if (this.left != null) {
        this.left.postOrder();
    }
    if (this.right != null) {
        this.right.postOrder();
    }
    System.out.print(this.value + " ");
}

3.查找

3.1查找节点

在class Node中创建search方法查找节点。判断传入的值和当前节点的值是否相等，相等就返回当前节点的值，如果不相等，判断查找的值是否小于当前节点，如果小于就向左子树递归查找，如果大于就向右子树递归查找。

public Node search(int value) {
    if (value == this.value) {
        return this;
    } else if (value < this.value) { // 如果查找的值小于当前节点，向左子树递归查找
        if (this.left == null) {
            return null;
        }
        return this.left.search(value);
    } else { //如果查找的值大于当前节点，向右子树递归查找
        if (this.right == null) {
            return null;
        }
        return this.right.search(value);
    }
}

3.2查找父节点

在class Node中创建searchParent方法查找父节点。

public Node searchParent(int value) {
    // 如果当前节点就是要删除的节点的父节点
    if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {
        return this;
    } else {
        // 如果查找的值小于当前的值，并且左节点不为空
        if (value < this.value && this.left != null) {
            return this.left.searchParent(value);
        } else if (value >= this.value && this.right != null) {
            return this.right.searchParent(value);
        } else {
            return null;
        }
    }
}

4.删除节点

删除要分三种情况

1. 删除子叶节点 先找到要删除的节点targetNode，再找到它的父节点，判断targetNode是父节点的左子节点还是右子点进行删除
2. 删除只有一颗子树的节点 先找到要删除的节点targetNode，再找到它的父节点，然后判断targetNode的子节点为左子节点还是右子节点，如果targetNode的子节点为左子节点，parentNode.left = targetNode.left。如果targetNode的子节点为右子节点，parentNode.right = targetNode.left。
3. 删除两颗子树的节点
   先找到要删除的节点targetNode，再找到它的父节点，然后从targetNode的右子树找到最小，使用变量minValue存放最小值，再删除最小节点targetNode.value = minValue;

public int delRightTreeMin(Node node) {
    Node targetNode = node;
    // 循环查找左子节点，找到最小值
    while (targetNode.left != null) {
        targetNode = targetNode.left;
    }
    // 删除最小节点
    delNode(targetNode.value);
    return targetNode.value;
}

public void delNode(int value) {
        if (root == null) {
            return;
        } else {
            Node targetNode = search(value); // 找到要删除的目标节点
            if (targetNode == null) { // 如果没找到
                return;
            }
            //targetNode如果为根节点
//            if (root == targetNode) {
            if (root.left == null && root.right == null) {
                root = null;
                return;
            }
            Node parentNode = searchParent(value);
            if (targetNode.left == null && targetNode.right == null) { // 如果是叶子节点
                // 判断targetNode是parentNode的左子节点还是右子节点
                if (parentNode.left != null && parentNode.left.value == value) { // 左子节点
                    parentNode.left = null;
                } else if (parentNode.right != null && parentNode.right.value == value) { // 右子节点
                    parentNode.right = null;
                }
            } else if (targetNode.left != null && targetNode.right != null) { // 两颗子树的情况
                int minValue = delRightTreeMin(targetNode.right);
                targetNode.value = minValue;
            } else { // 一颗子树的情况
                if (targetNode.left != null) {
                    if (parentNode != null) {// targetNode是parentNode的左子节点
                        if (parentNode.left.value == value) {
                            parentNode.left = targetNode.left;
                        } else { // targetNode是parentNode的右子节点
                            parentNode.right = targetNode.left;
                        }
                    } else {
                        root = targetNode.left;
                    }
                } else { // targetNode是parentNode的右子节点
                    if (parentNode != null) {
                        if (parentNode.left.value == value) {
                            parentNode.left = targetNode.right;
                        } else {
                            parentNode.right = targetNode.right;
                        }
                    } else {
                        root = targetNode.right;
                    }
                }
            }
        }
    }

5.源代码

package com.zhu.test;

public class BinarySortTreeDemo {
    public static void main(String[] args) {
        int[] arr = {7, 3, 10, 12, 5, 1, 9, 0};
        BinarySortTree binarySortTree = new BinarySortTree();
        for (int i = 0; i < arr.length; i++) {
            binarySortTree.add(new Node(arr[i]));
        }
        System.out.println("=======先序遍历二叉排序树==========");
        binarySortTree.perOrder();
        System.out.println();
        System.out.println("+++++++中序遍历二叉排序树++++++++++");
        binarySortTree.infixOrder();
        System.out.println();
        System.out.println("=======后序遍历二叉排序树==========");
        binarySortTree.postOrder();
        System.out.println();
        binarySortTree.delNode(2);
        binarySortTree.delNode(5);
        binarySortTree.delNode(9);
        binarySortTree.delNode(12);
        binarySortTree.delNode(7);
        binarySortTree.delNode(3);

        binarySortTree.delNode(0);
        binarySortTree.delNode(10);

        System.out.println("=======删除节点后中序遍历二叉排序树==========");
        binarySortTree.infixOrder();

    }
}

//创建二叉排序树
class BinarySortTree {
    private Node root;

    // 查找要删除的节点
    public Node search(int value) {
        if (root == null) {
            return null;
        } else {
            return root.search(value);
        }
    }

    // 查找父节点
    public Node searchParent(int value) {
        if (root == null) {
            return null;
        } else {
            return root.searchParent(value);
        }
    }

    public int delRightTreeMin(Node node) {
        Node targetNode = node;
        // 循环查找左子节点，找到最小值
        while (targetNode.left != null) {
            targetNode = targetNode.left;
        }
        // 删除最小节点
        delNode(targetNode.value);
        return targetNode.value;
    }

    // 删除节点
    public void delNode(int value) {
        if (root == null) {
            return;
        } else {
            Node targetNode = search(value); // 找到要删除的目标节点
            if (targetNode == null) { // 如果没找到
                return;
            }
            //targetNode如果为根节点
//            if (root == targetNode) {
            if (root.left == null && root.right == null) {
                root = null;
                return;
            }
            Node parentNode = searchParent(value);
            if (targetNode.left == null && targetNode.right == null) { // 如果是叶子节点
                // 判断targetNode是parentNode的左子节点还是右子节点
                if (parentNode.left != null && parentNode.left.value == value) { // 左子节点
                    parentNode.left = null;
                } else if (parentNode.right != null && parentNode.right.value == value) { // 右子节点
                    parentNode.right = null;
                }
            } else if (targetNode.left != null && targetNode.right != null) { // 两颗子树的情况
                int minValue = delRightTreeMin(targetNode.right);
                targetNode.value = minValue;
            } else { // 一颗子树的情况
                if (targetNode.left != null) {
                    if (parentNode != null) {// targetNode是parentNode的左子节点
                        if (parentNode.left.value == value) {
                            parentNode.left = targetNode.left;
                        } else { // targetNode是parentNode的右子节点
                            parentNode.right = targetNode.left;
                        }
                    } else {
                        root = targetNode.left;
                    }

                } else { // targetNode是parentNode的右子节点
                    if (parentNode != null) {
                        if (parentNode.left.value == value) {
                            parentNode.left = targetNode.right;
                        } else {
                            parentNode.right = targetNode.right;
                        }
                    } else {
                        root = targetNode.right;
                    }

                }
            }

        }
    }

    //添加节点
    public void add(Node node) {
        if (root == null) {
            root = node;
        } else {
            root.add(node);
        }
    }

    public void perOrder() {
        if (root != null) {
            root.preOrder();
        } else {
            System.out.println("root为空!!!");
        }
    }

    // 中序遍历
    public void infixOrder() {
        if (root != null) {
            root.infixOrder();
        } else {
            System.out.println("root为空!!!");
        }
    }

    public void postOrder() {
        if (root != null) {
            root.postOrder();
        } else {
            System.out.println("root为空!!!");
        }
    }
}

// 创建节点
class Node {
    int value;
    Node left;
    Node right;

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


    /**
     * 查找节点
     *
     * @param value 删除节点的值
     * @return 找到返回value 找不到返回null
     */
    public Node search(int value) {
        if (value == this.value) {
            return this;
        } else if (value < this.value) { // 如果查找的值小于当前节点，向左子树递归查找
            if (this.left == null) {
                return null;
            }
            return this.left.search(value);
        } else { //如果查找的值大于当前节点，向右子树递归查找
            if (this.right == null) {
                return null;
            }
            return this.right.search(value);
        }
    }

    //查找父节点
    public Node searchParent(int value) {
        // 如果当前节点就是要删除的节点的父节点
        if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {
            return this;
        } else {
            // 如果查找的值小于当前的值，并且左节点不为空
            if (value < this.value && this.left != null) {
                return this.left.searchParent(value);
            } else if (value >= this.value && this.right != null) {
                return this.right.searchParent(value);
            } else {
                return null;
            }
        }
    }

    @Override
    public String toString() {
        return "Node{" +
                "value = " + value +
                '}';
    }

    // 添加节点
    public void add(Node node) {
        if (node == null) {
            return;
        }
        // 判断传入的节点值
        if (node.value < this.value) {
            if (this.left == null) { //左子树为空
                this.left = node;
            } else { // 左子树不为空：递归向左子树添加
                this.left.add(node);
            }
        } else { // 添加的值>当前节点的值
            if (this.right == null) {
                this.right = node;
            } else {
                //递归向右子树添加
                this.right.add(node);
            }
        }
    }

    // 中序遍历
    public void infixOrder() {
        if (this.left != null) {
            this.left.infixOrder();
        }
        System.out.print(this.value + " ");
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

    // 先序
    public void preOrder() {
        System.out.print(this.value + " ");
        if (this.left != null) {
            this.left.preOrder();
        }
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    // 后续
    public void postOrder() {
        if (this.left != null) {
            this.left.postOrder();
        }
        if (this.right != null) {
            this.right.postOrder();
        }
        System.out.print(this.value + " ");
    }
}