树结构-二叉查找树

前言

1.二叉树，即任意一个结点下面不能有超过两个子节点

2.二叉查找树的特点为，左子结点小于父结点，父结点小于右子结点

代码实现

public class BinaryTree<K extends Comparable,V> {

    //根结点
    private Node<K,V> root;
    private int size;

    public BinaryTree() {
        root = null;
        size =0;
    }

    //往树中插入一个元素
    public void put(K key,V value){
        root = put(root,key,value);
    }

    //在给定的树x中，插入一个元素，并返回新树
    public Node put(Node<K,V> x,K key,V value){
        //如果结点为null
        if(x==null){
            size++;
            return new Node(key,value,null, null);
        }

        int comp = key.compareTo(x.key);
        if (comp>0){
            //如果插入的元素比x结点大，则新增元素放到x结点的右边
            x.right = put(x.right,key,value);
        }else if (comp<0){
            //如果插入的元素比x结点小，则新增元素放到x结点的左边
            x.left = put(x.left,key,value);
        }else {
            //相等则替换
            x.value = value;
        }
        return x;
    }

    /**
     *
     * 删除原理：
     * 1.假如要删除的结点为x,则首先需要找出x结点
     * 2.从x的右子树中找出最小值结点min,用min结点替换x结点的位置。
     * @param key
     */
    //从树中删除结点
    public void deleteNode(K key){
        deleteNode(root,key);
    }

    //从给定的树中删除结点，并返回删除后的新树
    public Node deleteNode(Node<K,V> x, K key){
        if (x==null){
            return null;
        }
        //找出要删除的结点
        int comp = key.compareTo(x.key);
        if (comp>0){
            x.right = deleteNode(x.right,key);
        }else if (comp<0){
            x.left = deleteNode(x.left,key);
        }else {
            //相等则找到要删除的结点
            size--;
            if (x.right==null){
                //如果右子树为空。则直接返回左子树即可
               return x.left;
            }
            if (x.left ==null){
                //如果左子树为空。则直接返回右子树即可
                return x.right;
            }

            //找出右子树中最小值
            Node rightMinNode = x.right;
            while (rightMinNode.left!=null){
                rightMinNode = rightMinNode.left;
            }

            //在右子树中删除最小值结点
            Node n = x.right;
            while (n.left!=null){
                if (n.left.left == null){
                    n.left = null;
                    break;
                }
                n = n.left;
            }

            //让rightMinNode的左子树等于x的左子树
            rightMinNode.left = x.left;
            //让rightMinNode的右子树等于x的右子树
            rightMinNode.right = x.right;
            //让rightMinNode的父结点等于x的父结点
            x = rightMinNode;

        }
        return x;
    }

    //从树中查找健等于key的结点的值
    public V get(K key){
        return get(root,key);
    }
    //从给定的树中，查找出key对应的值
    public V get(Node<K,V> x,K key){
        //如果x结点为null，则直接返回null
        if (x==null){
            return null;
        }

        //比较x结点的key与传入的key
        int comp = key.compareTo(x.key);
        if (comp>0){
            //如果传入的key大于x的key,则继续往x结点的右子树查找
            return get(x.right,key);
        }else if (comp<0){
            return get(x.left,key);
        }else {
            return x.value;
        }
    }


    public int size(){
        return size;
    }

    private class Node<K,V>{
        private K key;
        private V value;
        private Node<K,V> left;//左子树
        private Node<K,V> right;//右子树

        public Node(K key, V value, Node<K, V> left, Node<K, V> right) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }

}

测试：

    public static void main(String[] args) {
        BinaryTree<Integer, String> bt = new BinaryTree<>();
        bt.put(8,"aaa");
        bt.put(12,"bbb");
        bt.put(6,"ccc");
        bt.put(3,"ddd");
        System.out.println(bt.size());

        bt.deleteNode(6);

        System.out.println(bt.size());

        System.out.println(bt.get(6));

    }

结点是否符合左结点小于父结点，父结点小于右结点，需要打断点调试查看。