Java语言实现二叉排序树的创建和删除节点

  • 二叉排序树
    二叉排序树中任意一个非叶子节点的值,大于其左子节点的值,小于其右子节点的值。如果有相等的值,可以放在左子节点或者右子节点。
删除节点

删除节点分为三种情况

  • 删除的节点是叶子结点
  • 删除的节点是非叶子节点,但是只有一棵子树,左子树或者右子树
  • 删除的节点是非叶子节点,有两棵子树

1.删除叶子结点
  • 先找到待删除节点
  • 再找到它的父节点
  • 确定待删除节点是父节点的左子节点还是右子节点
  • 如果是左子节点,将父节点的左子节点置空;右子节点同理
2.删除有一颗子树的节点
  • 先找到待删除节点
  • 再找到它的父节点
  • 如果待删除节点有左子节点,
    • 如果待删除节点是父节点的左子节点,就将父节点的左指针指向待删除节点的左子节点
    • 如果待删除节点是父节点的右子节点,就将父节点的右指针指向待删除节点的左子节点
  • 如果待删除节点有右子节点,
    • 如果待删除节点是父节点的左子节点,就将父节点的左指针指向待删除节点的右子节点
    • 如果待删除节点是父节点的右子节点,就将父节点的右指针指向待删除节点的右子节点
3.删除有两棵子树的节点
  • 先找到待删除节点
  • 再找到它的父节点
  • 从待删除节点的右子树中找到值最小的节点(要么是叶子结点,要么是只有一棵右子树的非叶子节点),并用变量记录下这个节点的值
  • 删除这个值最小的节点
  • 将待删除节点的值改为这个最小值
4.代码
  • 定义节点类
public class Node {
    private int value;
    private Node left;
    private Node right;

    public Node(int value) {
        this.value = value;
    }
	//getter   setter   toString

    //添加节点,构建二叉排序树
    public void addNode(Node node){
        if (node == null){
            return;
        }
        if (node.getValue()<this.getValue()){
            if (this.getLeft()!=null){
                this.getLeft().addNode(node);
            }else {
                this.setLeft(node);
            }
        }else {
            if (this.getRight()!=null){
                this.getRight().addNode(node);
            }else {
                this.setRight(node);
            }
        }
    }

    //中序遍历
    public void midOrder(){
        if (this.getLeft() != null){
            this.getLeft().midOrder();
        }
        System.out.println(this);
        if (this.getRight() != null){
            this.getRight().midOrder();
        }
    }

    //查找要删除的节点
    public Node searchNode(int value){
        if (this.value == value){
            return this;
        }
        else if (this.value > value){
            if (this.getLeft() == null){
                return null;
            }
            return this.getLeft().searchNode(value);
        }else {
            if (this.getRight() == null){
                return null;
            }
            return this.getRight().searchNode(value);
        }
    }

    //查找要删除节点的父节点
    public Node searchParentNode(int value){
        if ((this.getLeft() != null && this.getLeft().value == value)
                || (this.getRight() != null && this.getRight().value == value)){
            return this;
        }else {
            if (this.getValue() > value && this.getLeft() != null){
                return this.getLeft().searchParentNode(value);
            }else
                if (this.getValue() <= value && this.getRight() != null){
                    return this.getRight().searchParentNode(value);
                }
                else {
                    return null;
                }
        }
    }
}
  • 定义二叉排序树类,定义相关方法
public class BinarySortTree {
    private Node root;

    public Node getRoot() {
        return root;
    }

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

    public void midOrder(){
        if (root == null){
            return;
        }else {
            root.midOrder();
        }
    }

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

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

    //删除节点
    public void deleteNode(int value){
        if (root == null){
            return;
        }else {
            Node deleteNode = searchNode(value);
            if (deleteNode == null){
                return;
            }
            if (root.getLeft() == null && root.getLeft() == null){
                root = null;
                return;
            }

            Node parentNode = searchParentNode(value);
            //如果为叶子节点
            if (deleteNode.getLeft() == null && deleteNode.getRight() == null){
                if (parentNode.getRight() == deleteNode){
                    parentNode.setRight(null);
                }else if (parentNode.getLeft() == deleteNode){
                    parentNode.setLeft(null);
                }
            }else
                //如果为有两棵树的非叶子节点
                if (deleteNode.getLeft() != null && deleteNode.getRight() != null){
                int rightMinNode = deleteRightMinNode(deleteNode.getRight());
                deleteNode.setValue(rightMinNode);
            }else {
                    //只有一颗子树的节点
                if (deleteNode.getLeft() != null){
                    if (parentNode != null){
                        if (parentNode.getLeft() == deleteNode){
                            parentNode.setLeft(deleteNode.getLeft());
                        }else if (parentNode.getRight() == deleteNode){
                            parentNode.setRight(deleteNode.getLeft());
                        }
                    }else {
                        root = deleteNode.getLeft();
                    }
                }else if (deleteNode.getRight() != null){
                    if (parentNode != null){
                        if (parentNode.getLeft() == deleteNode){
                            parentNode.setLeft(deleteNode.getRight());
                        }else if (parentNode.getRight() == deleteNode){
                            parentNode.setRight(deleteNode.getRight());
                        }
                    }else {
                        root = deleteNode.getRight();
                    }
                }
            }
        }
    }

    //删除右子树中最小值的节点
    public int deleteRightMinNode(Node node){
        while (node.getLeft() != null){
            node = node.getLeft();
        }
        int value = node.getValue();
        deleteNode(value);
        return value;
    }
}

  • 测试类
public class BinarySortTreeDemo {
    public static void main(String[] args) {
        int[] array = {7,3,10,12,11,5,1,9,2};
        BinarySortTree binarySortTree = new BinarySortTree();

        for (int i = 0; i < array.length; i++) {
            binarySortTree.addNode(new Node(array[i]));
        }
        binarySortTree.midOrder();
        System.out.println("-------------------------");

       binarySortTree.deleteNode(10);
       binarySortTree.midOrder();
    }
}

发布了25 篇原创文章 · 获赞 10 · 访问量 1156
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 游动-白 设计师: 上身试试

分享到微信朋友圈

×

扫一扫,手机浏览