数据结构——二叉排序树

需求：

​ 提供一个数组{7,3,10,12,5,1,9} 要求能够高效的完成对数据的查询与添加

• 数组：查询快速，但是添加删除性能差
• 链表：查询慢，但是添加删除快速
• 二叉排序树（BST）：查询和添加删除操作速度都很快

创建二叉排序树：

• 实现add添加方法
  1. 若添加的节点为null 直接返回
  2. 若添加节点小于比较的节点 在左子树，若左节点为空 直接赋值，若左子节点不为空，需要再判断与该左子节点的大小
     递归添加
• 实现createTree方法，遍历传入数组所有元素，挨个调用add方法添加节点，实现一颗二叉排序树的创建

代码：

   private node root; // 根节点
   public void init(node node){ // 初始化root节点
        if (node!=null)
            root = node;
    }    
	// 根据数组创建二叉排序树
    public void createTree(int[] array){
        int index = 0;
        if (root==null){
            System.out.println("root未初始化!现选取第一个元素初始化root");
            this.init(new node(array[0]));
            index = 1;
        }
        node node = null;
        for(int i=index;i<array.length;i++){ // 遍历array数组 创建二叉排序树
            node= new node(array[i]);
            addNode(root,node);
        }
    }
	// 添加新节点到二叉排序树
    public void addNode(node beginNode,node node){
        if (node.getValue() <= beginNode.getValue()){
            if (beginNode.getLeft() == null) {
                beginNode.setLeft(node);
                return;
            }
            addNode(beginNode.getLeft(),node);
        }else {
            if (beginNode.getRight() == null){
                beginNode.setRight(node);
                return;
            }
            addNode(beginNode.getRight(),node);
        }
    }

查询树的节点：

    // 在二叉排序树内查询指定节点
    public node searchNode(int value){
        if (root!=null)
            root.search(value);
        System.out.println("root未初始化!");
        return null;
    }
    // 在二叉树查询指定节点的父节点
    public node searchParent(int value){
        if (root.getValue() == value) // 如果查询节点为根节点 那么返回null
            return null;
        return root.searchParent(value);
    }

遍历二叉排序树：

    // 前序遍历二叉排序树
    public void preOrder(node node){
        if (node == null){
            System.out.println("node节点未初始化!");
            return;
        }
        node.preOrder();
    }
    // 前序遍历的无参重载
    public void preOrder(){
        System.out.println("前序遍历:");
        this.preOrder(root);
    }

删除节点：

思路：

根据删除节点的不同，可以将删除节点分为三类节点来分别讨论

1.叶子节点 2.只有一颗子树的节点 3.有两颗子树的节点

①叶子节点的删除

• 先遍历二叉排序树找到该节点delNode
• 再找到该节点的父节点parentNode(需要判别parentNode为空的情况，即delNode为root节点时的情况)
• 若delNode是parentNode的左子节点 parentNode.left = null 反之为parentNode.right = null

②有两颗子树的节点的删除

• 从targetNode的右子树内找到一个最小节点，记录保存该节点的值到一个临时变量temp内，然后删除该最小节点 将target节点的值赋值给targetNode节点
  （为什么要去右子树找最小节点，因为二叉排序树的特性 每一个节点的左子树都小于targetNode节点 右子树都大于targetNode节点 右子树的最小一个节点如果替换后刚好满足都大于左子树全部节点，都小于右子树最小节点 || 按照该思路，其实选取左子树最大的一个节点也可以实现该目标哦）可以以很小的代价实现带子树节点的删除

③只有一颗子树的节点的删除

• 先遍历二叉排序树找到该节点delNode
• 再找到该节点的父节点parentNode(需要判别parentNode为空的情况，即delNode为root节点时的情况)
• 若delNode是parentNode的左子节点 parent.left = delNode.left / right
• 若delNode是parentNode的右子节点 parent.right = delNode.left / right

代码：

    // 删除节点
    public void delNode(int value){
        if (root == null){
            System.out.println("root未初始化!");
            return;
        }
        node delNode = root.search(value);
        node parentNode = root.searchParent(value);
        if (delNode == null){
            System.out.println("无此节点,删除失败!");
            return;
        }
        // 如果删除节点是叶子节点
        if (delNode.getLeft()==null && delNode.getRight() == null) {
            // 1.如果是根节点 直接删除
            if (value == root.getValue() && root.getLeft() == null && root.getRight() == null) {
                root = null;
                return;
            }
            // 2.如果parentNode不为空 修改parentNode左右指针为null
            if (parentNode != null && parentNode.getLeft() == delNode) {
                parentNode.setLeft(null);
                return;
            }
            if (parentNode != null && parentNode.getRight() == delNode)
                parentNode.setRight(null);
        }else if (delNode.getLeft()!=null && delNode.getRight()!=null){  // 如果删除节点是有两颗子树的节点
            int minValue = delNode.getRight().findMinValue();
            delNode(minValue);
            delNode.setValue(minValue);
        }else { // 如果删除节点是有一颗子树的节点
            if (parentNode!=null){
                if (parentNode.getLeft() == delNode) { // 如果删除节点是parent的左子节点
                    // 如果delNode子节点为左节点赋左节点给Parent 有右节点赋值给parent
                    parentNode.setLeft((delNode.getLeft()!=null)?delNode.getLeft():delNode.getRight());
                }else if (parentNode.getRight() == delNode){ // 如果删除节点是parent的右子节点
                    parentNode.setRight((delNode.getLeft()!=null)?delNode.getLeft():delNode.getRight());
                }
            }else { // parent == null说明删除节点是根节点
                root = (delNode.getLeft()!=null)?delNode.getLeft() : delNode.getRight();
            }
        }
    }

完整代码与实例：

import javax.xml.soap.Node;

class node{
    private int value;
    private node left;
    private node right;
    public node(int value){
        this.value = value;
    }
    public int getValue() {
        return value;
    }
    public void setValue(int value) {
        this.value = value;
    }
    public node getLeft() {
        return left;
    }
    public void setLeft(node left) {
        this.left = left;
    }
    public node getRight() {
        return right;
    }
    public void setRight(node right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "value: "+value;
    }

    // 前序遍历
    public void preOrder(){
        System.out.println(this);
        if (this.left!=null)
            this.left.preOrder();
        if (this.right!=null)
            this.right.preOrder();
    }
    // 查询节点
    public node search(int value){
        if (this.value == value)
            return this;
        if (value < this.value){
            if (this.left == null)
                return null;
            return this.left.search(value);
        }
        if (this.right == null)
            return null;
        return this.right.search(value);
    }
    // 查询父节点
    public node searchParent(int value){
        // 1.判断当前节点是否就是要删除节点的父节点
        if ((this.left != null&& this.left.value == value)
                || (this.right!=null&&this.right.value==value))
            return this;
        // 2.查找的值小于当前节点并且当前左节点不为空 左子树递归
        if (value < this.value && this.left!=null)
            return this.left.searchParent(value);
        // 3.查找的值大于当前节点并且当前右节点不为空 右子树递归
        if (value > this.value && this.right!=null)
            return this.right.searchParent(value);
        // 4.什么都找不到 返回null
        return null;
    }

    // 返回子树内最小值
    public int findMinValue(int min){
        min = Math.min(min,this.value);
        if (this.left == null && this.right == null)
            return Math.min(min, this.value);
        if (this.left!=null){
            return Math.min(min,this.left.findMinValue(min));
        }
        return Math.min(min,this.right.findMinValue(min));
    }
    // 重载 findMinValue方法
    public int findMinValue(){
        return this.findMinValue(this.value);
    }
}
public class binarySortTreeDemo {
    private node root; // 根节点
    public void init(node node){ // 初始化root节点
        if (node!=null)
            root = node;
    }
    // 前序遍历二叉排序树
    public void preOrder(node node){
        if (node == null){
            System.out.println("node节点未初始化!");
            return;
        }
        node.preOrder();
    }
    // 前序遍历的无参重载
    public void preOrder(){
        System.out.println("前序遍历:");
        this.preOrder(root);
    }
    // 根据数组创建二叉排序树
    public void createTree(int[] array){
        int index = 0;
        if (root==null){
            System.out.println("root未初始化!现选取第一个元素初始化root");
            this.init(new node(array[0]));
            index = 1;
        }
        node node = null;
        for(int i=index;i<array.length;i++){ // 遍历array数组 创建二叉排序树
            node= new node(array[i]);
            addNode(root,node);
        }
    }
    // 添加新节点到二叉排序树
    public void addNode(node beginNode,node node){
        if (node.getValue() <= beginNode.getValue()){
            if (beginNode.getLeft() == null) {
                beginNode.setLeft(node);
                return;
            }
            addNode(beginNode.getLeft(),node);
        }else {
            if (beginNode.getRight() == null){
                beginNode.setRight(node);
                return;
            }
            addNode(beginNode.getRight(),node);
        }
    }
    // 在二叉排序树内查询指定节点
    public node searchNode(int value){
        if (root!=null)
            root.search(value);
        System.out.println("root未初始化!");
        return null;
    }
    // 在二叉树查询指定节点的父节点
    public node searchParent(int value){
        if (root.getValue() == value) // 如果查询节点为根节点 那么返回null
            return null;
        return root.searchParent(value);
    }
    // 删除节点
    public void delNode(int value){
        if (root == null){
            System.out.println("root未初始化!");
            return;
        }
        node delNode = root.search(value);
        node parentNode = root.searchParent(value);
        if (delNode == null){
            System.out.println("无此节点,删除失败!");
            return;
        }
        // 如果删除节点是叶子节点
        if (delNode.getLeft()==null && delNode.getRight() == null) {
            // 1.如果是根节点 直接删除
            if (value == root.getValue() && root.getLeft() == null && root.getRight() == null) {
                root = null;
                return;
            }
            // 2.如果parentNode不为空 修改parentNode左右指针为null
            if (parentNode != null && parentNode.getLeft() == delNode) {
                parentNode.setLeft(null);
                return;
            }
            if (parentNode != null && parentNode.getRight() == delNode)
                parentNode.setRight(null);
        }else if (delNode.getLeft()!=null && delNode.getRight()!=null){  // 如果删除节点是有两颗子树的节点
            int minValue = delNode.getRight().findMinValue();
            delNode(minValue);
            delNode.setValue(minValue);
        }else { // 如果删除节点是有一颗子树的节点
            if (parentNode!=null){
                if (parentNode.getLeft() == delNode) { // 如果删除节点是parent的左子节点
                    // 如果delNode子节点为左节点赋左节点给Parent 有右节点赋值给parent
                    parentNode.setLeft((delNode.getLeft()!=null)?delNode.getLeft():delNode.getRight());
                }else if (parentNode.getRight() == delNode){ // 如果删除节点是parent的右子节点
                    parentNode.setRight((delNode.getLeft()!=null)?delNode.getLeft():delNode.getRight());
                }
            }else { // parent == null说明删除节点是根节点
                root = (delNode.getLeft()!=null)?delNode.getLeft() : delNode.getRight();
            }
        }
    }
    public static void main(String[] args) {
        int[] arr = {7,3,10,12,5,1,9,2};
        binarySortTreeDemo binarySortTreeDemo = new binarySortTreeDemo();
        binarySortTreeDemo.createTree(arr);
        binarySortTreeDemo.root.preOrder();
        binarySortTreeDemo.delNode(1);
        binarySortTreeDemo.delNode(7);
        binarySortTreeDemo.preOrder();
        binarySortTreeDemo.delNode(3);
        binarySortTreeDemo.delNode(10);
        binarySortTreeDemo.delNode(2);
        binarySortTreeDemo.delNode(12);
        binarySortTreeDemo.delNode(9);
        binarySortTreeDemo.preOrder();

    }
}

输出结果：

root未初始化!现选取第一个元素初始化root
value: 7
value: 3
value: 1
value: 2
value: 5
value: 10
value: 9
value: 12
前序遍历:
value: 9
value: 3
value: 2
value: 5
value: 10
value: 12
前序遍历:
value: 5