数据结构-二叉搜索树Java实现

1，Node.java

生成基础二叉树的结构

package com.cnblogs.mufasa.searchTree;

/**
 * 节点配置父+左+右
 */
public class Node{
    Node parent;
    Node leftChild;
    Node rightChild;
    int val;
    public Node(Node parent, Node leftChild, Node rightChild,int val) {
        super();
        this.parent = parent;
        this.leftChild = leftChild;
        this.rightChild = rightChild;
        this.val = val;
    }

    public Node(int val){
        this(null,null,null,val);
    }

    public Node(Node node,int val){
        this(node,null,null,val);
    }
}

图1 Node.java结构

2，SearchBinaryTree.java

在原有二叉树的结构上，进行搜索二叉树的功能扩充：

①数据增加：递归版本插入、迭代版本

②数据删除：

③数据查找：

④数据遍历：前中后

package com.cnblogs.mufasa.searchTree;



public class SearchBinaryTree {

    private Node root;
    private int size;
    public SearchBinaryTree() {
        super();
    }

    /**
     * 增加节点
     * @param val
     * @return
     */
    public boolean add(int val) {
        if(root == null){//初始节点为空
            root = new Node(val);
            size++;
            return true;
        }
        //初始节点不为空
        Node node = getAdapterNode(root, val);
        Node newNode = new Node(val);
        if(node.val > val){
            node.leftChild = newNode;
            newNode.parent = node;
        }else if(node.val < val){
            node.rightChild = newNode;
            newNode.parent = node;
        }else{
            return false;//增加数据和搜索二叉树中原有数据相同不符合基本限定条件
        }
        size++;
        return true;
    }

    /**
     * 获取最合适的插入节点
     * @param node
     * @param val
     * @return
     */
    private Node getAdapterNode(Node node,int val){
        //该节点为空
        if(node == null){
            return node;
        }

        // 往左子树中插入，但没左子树，则返回
        if(node.val > val && node.leftChild == null){
            return node;
        }

        // 往右子树中插入，但没右子树，也返回
        if(node.val < val && node.rightChild == null){
            return node;
        }

        // 该节点是叶子节点，则返回
        if(node.leftChild == null && node.rightChild == null){
            return node;
        }

        //节点可以继续向下，直接递归调用
        if(node.val > val && node.leftChild != null){
            return getAdapterNode(node.leftChild, val);
        }else if(node.val < val && node.rightChild != null){
            return getAdapterNode(node.rightChild, val);
        }else{
            return node;
        }
    }

    /**
     * 进行迭代增加元素
     * @param val
     * @return
     */
    public boolean put(int val){
        return putVal(root,val);
    }

    /**
     *直接循环搜索目标节点进行数据增加
     * @param node
     * @param val
     * @return
     */
    private boolean putVal(Node node,int val){
        if(node == null){// 初始化根节点
            node = new Node(val);
            root = node;
            size++;
            return true;
        }
        //节点非空
        Node temp = node;
        Node p;
        int t;
        /**
         * 通过do while循环迭代获取最佳节点，
         */
        do{
            p = temp;
            t = temp.val-val;
            if(t > 0){
                temp = temp.leftChild;
            }else if(t < 0){
                temp = temp.rightChild;
            }else{
                temp.val = val;//增加数据和搜索二叉树中原有数据相同不符合基本限定条件
                return false;
            }
        }while(temp != null);

        Node newNode = new Node(p, val);
        if(t > 0){
            p.leftChild = newNode;
        }else if(t < 0){
            p.rightChild = newNode;
        }
        size++;
        return true;
    }

    /**
     * 节点删除
     * @param val
     * @return
     */
    public boolean delete(int val){
        Node node = getNode(val);
        if(node == null){//没有该节点
            return false;
        }
        Node parent = node.parent;
        Node leftChild = node.leftChild;
        Node rightChild = node.rightChild;

        //以下所有子节点为空的情况，则表明删除的节点是【叶节点】
        if(leftChild == null && rightChild == null){//没有子节点
            if(parent != null){
                if(parent.leftChild == node){
                    parent.leftChild = null;
                }else if(parent.rightChild == node){
                    parent.rightChild = null;
                }
            }else{//不存在父节点，则表明删除节点为【根节点】，直接返回空
                root = null;
            }
            node = null;
            return true;

        }else if(leftChild == null && rightChild != null){// 只有右节点
            if(parent != null && parent.val > val){// 存在父节点，且node位置为父节点的左边
                parent.leftChild = rightChild;
            }else if(parent != null && parent.val < val){// 存在父节点，且node位置为父节点的右边
                parent.rightChild = rightChild;
            }else{//父节点不存在！！！
                root = rightChild;
            }
            node = null;
            return true;

        }else if(leftChild != null && rightChild == null){// 只有左节点
            if(parent != null && parent.val > val){// 存在父节点，且node位置为父节点的左边
                parent.leftChild = leftChild;
            }else if(parent != null && parent.val < val){// 存在父节点，且node位置为父节点的右边
                parent.rightChild = leftChild;
            }else{//父节点不存在！！！
                root = leftChild;
            }
            node = null;
            return true;

        }else if(leftChild != null && rightChild != null){// 两个子节点都存在，相当于直接替换节点
            Node successor = getSuccessor(node);// 这种情况，一定存在后继节点
            int temp = successor.val;
            boolean delete = delete(temp);
            if(delete){
                node.val = temp;
            }
            successor = null;
            return true;
        }
        return false;
    }

    /**
     *
     * @param node
     * @return
     */
    private Node getSuccessor(Node node){
        if(node.rightChild != null){//肯定不为空
            Node rightChild = node.rightChild;
            while(rightChild.leftChild != null){//不断的向左转向搜索数值
                rightChild = rightChild.leftChild;
            }
            return rightChild;
        }
        //右节点为空这个不存在啊！！！
        Node parent = node.parent;
        while(parent != null && (node == parent.rightChild)){
            node = parent;
            parent = parent.parent;
        }
        return parent;
    }


    /**
     * 搜索节点
     * @param val
     * @return
     */
    public Node getNode(int val){
        Node temp = root;
        int t;
        do{//直接使用循环遍历的方法
            t = temp.val-val;
            if(t > 0){
                temp = temp.leftChild;
            }else if(t < 0){
                temp = temp.rightChild;
            }else{
                return temp;
            }
        }while(temp != null);
        return null;
    }

    /**
     * 节点删除
     * @param val
     * @return
     */
    public boolean remove(int val){
        Node node = getNode(val);
        if(node == null){
            return false;
        }

        if(node.leftChild == null){// 1、左节点不存在，右节点可能存在，包含两种情况  ，两个节点都不存在和只存在右节点
            transplant(node, node.rightChild);
        }else if(node.rightChild == null){//2、左孩子存在，右节点不存在
            transplant(node, node.leftChild);
        }else{// 3、两个节点都存在
            Node successor = getSuccessor(node);// 得到node后继节点
            if(successor.parent != node){// 后继节点存在node的右子树中。
                transplant(successor, successor.rightChild);// 用后继节点的右子节点替换该后继节点
                successor.rightChild = node.rightChild;// 将node节点的右子树赋给后继节点的右节点，即类似后继与node节点调换位置
                successor.rightChild.parent = successor;// 接着上一步  给接过来的右节点的父引用复制
            }
            transplant(node, successor);
            successor.leftChild = node.leftChild;
            successor.leftChild.parent = successor;
        }
        return true;
    }
    /**
     * 将child节点替换node节点
     * @param node    要删除的节点
     * @param child   node节点的子节点
     */
    private void transplant(Node node,Node child){
        /**
         * 1、先判断 node是否存在父节点
         *    1、不存在，则child替换为根节点
         *    2、存在，则继续下一步
         * 2、判断node节点是父节点的那个孩子(即判断出 node是右节点还是左节点)，
         *    得出结果后，将child节点替换node节点 ，即若node节点是左节点 则child替换后 也为左节点，否则为右节点
         * 3、将node节点的父节点置为child节点的父节点
         */

        if(node.parent == null){
            this.root = child;
        }else if(node.parent.leftChild == node){
            node.parent.leftChild = child;
        }else if(node.parent.rightChild == node){
            node.parent.rightChild = child;
        }
        if(child != null){
            child.parent = node.parent;
        }
    }

    public void print(int type){//方法的重载
        if(type==0){//前序
            printPre(root);
        }else if(type==1){
            printMid(root);
        }else if(type==2){
            printEnd(root);
        }
    }

    private void printPre(Node root){//前序遍历
        if(root != null){
            System.out.println(root.val);// 位置在中间，则中序，若在前面，则为先序，否则为后续
            printPre(root.leftChild);
            printPre(root.rightChild);
        }
    }

    private void printMid(Node root){//中序遍历
        if(root != null){
            printMid(root.leftChild);
            System.out.println(root.val);// 位置在中间，则中序，若在前面，则为先序，否则为后续
            printMid(root.rightChild);
        }
    }

    private void printEnd(Node root){//后序遍历
        if(root != null){
            printEnd(root.leftChild);
            printEnd(root.rightChild);
            System.out.println(root.val);// 位置在中间，则中序，若在前面，则为先序，否则为后续
        }
    }

}

 

图2 SearchBinaryTree.java结构

3，JavaDemo.java

package com.cnblogs.mufasa.searchTree;

public class JavaDemo {
    public static void main(String[] args) {
        SearchBinaryTree tree=new SearchBinaryTree();
        tree.add(5);
        tree.add(1);
        tree.add(100);
        tree.add(50);
        tree.add(22);
        tree.add(48);
        tree.print(2);
    }
}

4，特别鸣谢

https://www.cnblogs.com/qm-article/p/9279655.html