数据结构：二叉查找树简单实现 java

线性表

图的简单实现

Putf方法：主要是用递归。最后的x.left会递归给第一个put方法里的root，将他变成下一个树

 public void put(Key key, Value val) {
        root = put(root, key, val);
    }
    public Node put(Node x, Key key, Value val) {
        //如果这个树中是空的
        if (x == null) {
            N++;
            return new Node(key, val, null, null);
        }
        //如果这个树不是空的
        int tem = key.compareTo(x.key);
        if (tem < 0) {
            //如果是放入的key小于当前树的key，就递归，将树的位置换到x.left
            x.left = put(x.left, key, val);
        } else if (tem > 0) {
            //如果是放入的key大于当前树的key，就递归，将树的位置换到x.right
            x.right = put(x.right, key, val);
        }

 else {
        x.value =val;
    //如果相等了才能最后返回去放入的值是多少
}
return x;}

get方法就是通过递归找到想要的树，不行就重新调用，没什么好说的

 public Value get(Key key) {
        return get(root, key);
    }

    public Value get(Node x, Key key) {
        if (x == null) {
            return null;
        }
        //如果这个树不是空的
        if (key.compareTo(x.key) < 0) {
            //如果是放入的key小于当前树的key，就递归，将树的位置换到x.left

            return get(x.left, key);
        } else if (key.compareTo(x.key) > 0) {
            //如果是放入的key大于当前树的key，就递归，将树的位置换到x.right

            return get(x.right, key);
        } else {
            return x.value;
            //如果相等了才能最后返回去放入的值是多少
        }
    }

delete方法相对繁琐，主要是因为删除想要的结点后，原来结点下的左右子树不能够改变。

步骤：

• 判断是否是空的，如果是空，直接返回

• 如果是不是空，那么就需要通过递归查找到我们需要找到那个key

• 找到key之后仍然有三种情况

  • key下面的左子树不存在，那么直接将key下面的右子树，直接返回，替代原来key的位置

  • key下面的右子树不存在，那么直接将key下面的左子树，直接返回，替代原来key的位置

  • 如果下面的左右子树都存在

    • 那么就需要循环查找，找到最小的元素min，我们知道key的右子树的最左端可以用作新的key

    • 同时我们还需要删除那个最小元素

    • 将key原来的情况由新的min来代替，返回min

 public Node delete(Node x, Key key) {
        if (x == null) {
            //先需要判断是不是空的
            return null;
            //如果是空的直接返回null
        }
        int tem = key.compareTo(x.key);
        //如果不是空的。
        if (tem < 0) {
            x.left = delete(x.left, key);
        } else if (tem > 0) {
            x.right = delete(x.right, key);
        } else {
            //通过递归调用通过key值的比较，找到key的位置。
            //这里是找到了想要删除的结点的位置
            if (x.left == null) {
                //如果找到的key的左子树不存在，那么key的右子树就直接充当当前需要删除元素位置的结点。
                N--;
                return x.right;
            } else if (x.right == null) {
                //如果找到的key的右子树不存在，那么key的左子树就直接充当当前需要删除元素位置的结点。
                N--;
                return x.left;
            } else {
                //如果key的左右子树都存在，那么就需要找key下面右子树的最小值
                Node minNode = x.right;
                Node tem02 = null;
                while (minNode.left != null) {
                    //这种是双指针的执行，找到minNode的父结点
                    tem02 = minNode;
                    minNode = minNode.left;
                }//这里就是找到他的最小值了
                tem02.left = null;
//                ------------------------------------------------------------------
                //下面的执行方式便于理解，分开来进行
//                while (minNode.left != null) {
//                    minNode = minNode.left;
//                }
//                Node tem02 = x.right;
//                while (tem02.left != null) {
//                    if (tem02.left.left == null) {
//                       tem02.left = null;
//                    }
//                    else {
//                        tem02 =tem02.left;
//                    }
//                }
                minNode.left = root.left;
                minNode.right = root.right;
                N--;
                x = minNode;
                //需要删除最小值，并且，将最小值变成需要找到key的位置：将原来的key值删除，并且将最小值的位置变成原来key的位置

            }
        }
        return x;
    }