二叉搜索树简介

/**
 * Created by dupang on 2017/11/12.
 */
public class TreeNode<T> {

    /**
     * 节点的左孩子
     */
    private TreeNode<T> left;
    /**
     * 节点的右孩子
     */
    private TreeNode<T> right;
    /**
     * 节点的父亲
     */
    private TreeNode<T> parent;
    /**
     * 节点的值
     */
    private T value;

    public TreeNode(){

    }
    public TreeNode(TreeNode<T> left,TreeNode<T> right,TreeNode<T> parent,T value){
        this.left=left;
        this.right=right;
        this.parent=parent;
        this.value=value;
    }

    public TreeNode<T> getLeft() {
        return left;
    }

    public void setLeft(TreeNode<T> left) {
        this.left = left;
    }

    public TreeNode<T> getRight() {
        return right;
    }

    public void setRight(TreeNode<T> right) {
        this.right = right;
    }

    public TreeNode<T> getParent() {
        return parent;
    }

    public void setParent(TreeNode<T> parent) {
        this.parent = parent;
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

/**
 * Created by dupang on 2017/11/12.
 */
public class SearchTreeTest {
    public static void main(String[] args) {
        int[] values = new int[]{18,5,3,9,2,13,32};
        //初始化一个表示树的根节点
        TreeNode<Integer> root = new TreeNode<>(null,null,null,null);

        //遍历插入
        for (Integer value:values){
            //初始化要插入的节点
            TreeNode<Integer> treeNode = new TreeNode<>(null,null,null,value);
            insert(root,treeNode);
        }

        //中序遍历
        inOrderTreeWalk(root);
        System.out.println();
        //先序遍历
        preOrderTreeWalk(root);
        System.out.println();
        //后序遍历
        postOrderTreeWalk(root);
        System.out.println();

        TreeNode<Integer> treeNode = treeSearch(root,3);
        //求最大值
        treeMaximum(root);
        //求最小值
        treeMinimum(root);
        //后继
        treeSuccessor(root);
        //前驱
        treeSuccessor(root);
    }

    /**
     * 二叉搜索树的插入操作
     * @param root 二叉树的根
     * @param tTreeNode 要插入的节点
     */
    public static void insert(TreeNode<Integer> root,TreeNode<Integer> tTreeNode){
        //声明一个y，用于记录while循环中循环节点的位置，也就是插入节点要插入的位置
        TreeNode<Integer> y = null;
        //把树的根节点赋值给x,先从根节点开始寻找插入的点。
        TreeNode<Integer> x = root;
        while (x!=null&&x.getValue()!=null){
            y=x;
            //如果要插入的值比根节点的值大，
            if(tTreeNode.getValue()>x.getValue()){
                x = x.getRight();
            }else {
                x= x.getLeft();
            }
        }
        //如果y是null，说明是个空树
        if(y==null){
            root.setParent(null);
            root.setLeft(null);
            root.setRight(null);
            root.setValue(tTreeNode.getValue());
        }else if(tTreeNode.getValue()>y.getValue()){
            y.setRight(tTreeNode);
            tTreeNode.setParent(y);
        }else {
            y.setLeft(tTreeNode);
            tTreeNode.setParent(y);
        }
    }

    /**
     * 中序遍历
     * @param treeNode 根节点
     */
    public static void inOrderTreeWalk(TreeNode<Integer> treeNode){
        if (treeNode!=null&&treeNode.getValue()!=null){
            inOrderTreeWalk(treeNode.getLeft());
            System.out.print(treeNode.getValue()+" ");
            inOrderTreeWalk(treeNode.getRight());
        }
    }
    /**
     * 前序遍历
     * @param treeNode 根节点
     */
    public static void preOrderTreeWalk(TreeNode<Integer> treeNode){
        if (treeNode!=null&&treeNode.getValue()!=null){
            System.out.print(treeNode.getValue()+" ");
            inOrderTreeWalk(treeNode.getLeft());
            inOrderTreeWalk(treeNode.getRight());
        }
    }
    /**
     * 后序遍历
     * @param treeNode 根节点
     */
    public static void postOrderTreeWalk(TreeNode<Integer> treeNode){
        if (treeNode!=null&&treeNode.getValue()!=null){
            inOrderTreeWalk(treeNode.getLeft());
            inOrderTreeWalk(treeNode.getRight());
            System.out.print(treeNode.getValue()+" ");
        }
    }

    /**
     * 在树中查询指定值的节点
     * @param treeNode 树的节点
     * @param k 要查询的值
     * @return 如果查询到节点的值等于要查询的值，就返回这个节点，否则返回null
     */
    public static TreeNode<Integer> treeSearch(TreeNode<Integer> treeNode,Integer k){
        if(treeNode==null||treeNode.getValue()==null||treeNode.getValue()==k){
            return treeNode;
        }
        if(k>treeNode.getValue()){
            return treeSearch(treeNode.getRight(),k);
        }else {
            return treeSearch(treeNode.getLeft(),k);
        }
    }

    /**
     * 在树中找到最大值
     * @param treeNode 树的节点
     * @return 如果查询到节点的值等于要查询的值，就返回这个节点，否则返回null
     */
    public static TreeNode<Integer> treeMaximum(TreeNode<Integer> treeNode){
        while (treeNode.getRight()!=null){
            treeNode = treeNode.getRight();
        }
        return treeNode;
    }

    /**
     * 在树中找到最小值
     * @param treeNode 树的节点
     * @return 如果查询到节点的值等于要查询的值，就返回这个节点，否则返回null
     */
    public static TreeNode<Integer> treeMinimum(TreeNode<Integer> treeNode){
        while (treeNode.getLeft()!=null){
            treeNode = treeNode.getLeft();
        }
        return treeNode;
    }

    /**
     * 找一个节点的后继
     * @return 一个节点的后继
     */
    public static TreeNode<Integer> treeSuccessor(TreeNode<Integer> treeNode){
        if(treeNode.getRight()!=null){
            return treeMinimum(treeNode.getRight());
        }
        TreeNode<Integer> y = treeNode.getParent();
        while (y!=null && treeNode==y.getRight()){
            treeNode = y;
            y = y.getParent();
        }
        return y;
    }
    /**
     * 找一个节点的前驱
     * @return 一个节点的前驱
     */
    public static TreeNode<Integer> treePredecessor(TreeNode<Integer> treeNode){
        if(treeNode.getLeft()!=null){
            return treeMaximum(treeNode.getLeft());
        }
        TreeNode<Integer> y = treeNode.getParent();
        while (y!=null && treeNode==y.getLeft()){
            treeNode = y;
            y = y.getParent();
        }
        return y;
    }

    public static void transplant(TreeNode<Integer> root,TreeNode<Integer> target,TreeNode<Integer> source){
        if(target.getParent()==null){
            root.setValue(source.getValue());
            root.setLeft(source.getLeft());
            root.setRight(source.getRight());
            root.setParent(source.getParent());
        }else if(target == target.getParent().getLeft()){
            target.getParent().setLeft(source);
        }else {
            target.getParent().setRight(source);
        }
        source.setParent(target.getParent());
    }

    /**
     * 从一棵树中删除一个节点
     * @param root 根节点
     * @param delete 要删除的节点
     */
    public void treeDelete(TreeNode<Integer> root ,TreeNode<Integer> delete){
        if(delete.getLeft()==null){
            transplant(root,delete,delete.getRight());
        }else if(delete.getRight()==null){
            transplant(root,delete,delete.getLeft());
        }else {
            TreeNode<Integer> y = treeMinimum(delete.getRight());
            if(y.getParent()!=delete){
                transplant(root,y,y.getRight());
                y.setRight(delete.getRight());
                y.getRight().setParent(y);
            }
            transplant(root,delete,y);
            y.setLeft(delete.getLeft());
            y.getLeft().setParent(y);
        }
    }
}