树（二）——二叉树

二叉树的定义

二叉树就是度不超过2的树。

**满二叉树：**一个二叉树，如果每一层的结点都达到最大值，则这个二叉树就是满二叉树。
**完全二叉树：**叶结点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树。

核心代码实现

package tree;

public class BinaryTree<Key extends Comparable<Key>,Value> {
    //记录根节点
    private Node root;
    //记录树中元素的个数
    private int N;

    private class Node{
        //存储键
        public Key key;
        //存储值
        private Value value;
        //记录左子结点
        public Node left;
        //记录右子结点
        public Node right;

        public Node(Key key,Value value,Node left,Node right){
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }

    //获取树中元素的个数
    public int size(){
        return N;
    }

    //向树中添加元素key-value
    public void put(Key key,Value value){
        root = put(root,key,value);
    }

    //向指定的树x中添加key-value，并返回添加元素后的新树
    private Node put(Node x,Key key,Value value){
        //如果x子树为空
        if(x==null){
            N++;
            return new Node(key,value,null,null);
        }
        //如果x子树不为空
        int cmp = key.compareTo(x.key);
        if(cmp>0){
            x.right = put(x.right,key,value);
        }else if(cmp<0){
            x.left = put(x.left,key,value);
        }else {
            x.value = value;
        }
        return x;
    }

    //查询树中指定key对应的value
    public Value get(Key key){
        return get(root,key);
    }

    //查询指定的树x中，查找key对应的值。
    public Value get(Node x,Key key){
        //x树为null
        if(x==null){
            return null;
        }
        //x树不为null
        int cmp = key.compareTo(x.key);
        if(cmp>0){
            return get(x.right,key);
        }else if(cmp<0){
            return get(x.left,key);
        }else {
            return x.value;
        }

    }

    //删除树中key对应的value
    public void delete(Key key){
        delete(root,key);
    }

    //删除指定的树x中的key对应的value，并返回新的树
    public Node delete(Node x,Key key){
        //x树为null
        if(x==null){
            return null;
        }
        //x树不为null
        int cmp = key.compareTo(x.key);
        if(cmp>0){
           //如果key大于x结点的键，则继续找x结点的右子树
            x.right = delete(x.right,key);
        }else if(cmp<0){
            //如果key小于x结点的键，则继续找x结点的左子树
            x.left = delete(x.left,key);
        }else {
            //如果key等于x结点的键，完成真正的删除结点动作，要删除的结点就是x

            //让元素个数减一
            N--;

            //找到右子树中最小的结点
            if(x.right == null){
                return x.left;
            }

            if(x.left == null){
                return x.right;
            }

            Node minNode = x.right;
            while(minNode.left!=null){
                minNode = minNode.left;
            }

            //删除右子树中最小的结点
            Node n = x.right;
            while(n.left!=null){
                if(n.left.left == null){
                    n.left = null;
                }else{
                    //变换n结点
                    n = n.left;
                }
            }

            //让x结点的左子树成为minNode的左子树
            minNode.left = x.left;
            //让x结点的右子树成为minNode的右子树
            minNode.right = x.right;
            //让x结点的父节点指向minNode
            x = minNode;

        }

        return x;
    }
}

package test;

import tree.BinaryTree;

public class BinaryTreeTest {
    public static void main(String[] args) {
        BinaryTree<Integer,String> binaryTree = new BinaryTree<>();

        //测试插入
        binaryTree.put(1,"张三");
        binaryTree.put(2,"李四");
        binaryTree.put(3,"王五");
        System.out.println(binaryTree.size());
        //测试获取
        System.out.println(binaryTree.get(2));
        //测试删除
        binaryTree.delete(3);
        System.out.println(binaryTree.size());

    }
}