Java数据结构学习之树

public class MyBSTree<T extends Comparable<T>> {

    private node root;//二叉搜索树根节点
    private int size;//二叉搜索树结点个数

    //添加结点
    public boolean add(T value) {
        // 对于一个二叉搜索树来讲我们不存储null: null不能比较大小
        if (value == null)
            throw new IllegalArgumentException("The param is null");
        //判断原本的树是否为空
        if (root == null) {
            // 如果原本的树是一个空树, 那么这个添加的元素就是根节点
            root = new Node(value, null, null);
            size++;
            return true;
        }

        //目前来看，树不空，值也不是null
        Node index = root;//比较结点
        Node indexF = null;//比较结点的父结点
        int com = 0;//比较value大小结果
        while (index != null) {
            // 把要存储的值, 和遍历结点作比较, 进一步确定相对于mid存储的位置
            com = index.value.compareTo(value);
            indexF = index;
            if (com > 0) {
                index = index.left;
            } else if (com < 0) {
                index = index.right;
            } else {
                // com = 0
                // value 和 index存储的值一样
                // 对于重复元素的处理方式
                //       理论上:
                //                1, 计数法:  对于每一个结点都额外维护一个参数, 记录这个元素的重复数量
                //                2, 拉链法: 在某个结点位置维护一个链表, 用一个链表代表一个结点
                //                3, 修正的BST: 如果比较的过程中发现了重复元素, 向左存储
                //       实际上:
                //             不让存
                return false;
            }
        }

        if (com > 0) {
            indexF.left = new Node(value, null, null);
        } else {
            indexF.right = new Node(value, null, null);
        }
        size++;
        return true;
    }

    //是否存在指定值
    public boolean contains(T value) {
        // 对于一个二叉搜索树来讲我们不存储null: null不能比较大小
        if (value == null)
            throw new IllegalArgumentException("The param is null");

        Node index = root;
        int com = 0;
        while (index != null) {
            com = value.compareTo(index.value);
            if (com > 0) {
                index = index.right;
            } else if (com < 0) {
                index = index.left;
            } else return true;
        }
        //如果代码走到这个位置, 意味着上述循环跳出条件是: index == null 意味着没有这个元素
        return false;
    }
    //递归方法删除二叉搜索树结点
    public boolean removeByRecursive(T value){
        int oldSize = size;
        root = removeByRe(root,value);
        return size<oldSize;
    }
    // 实现以root为根节点的子树上删除值为value的结点
    private Node removeByRe(Node root,T value){
        if (root == null) return null;
        int com = value.compareTo(root.value);
        if (com>0){
            //如果value存在, 在right子树上
            root.right = removeByRe(root.right,value);
            return root;
        }else if (com<0){
            //如果value存在, 在left子树上
            root.left = removeByRe(root.left,value);
            return root;
        }else{
            // 找到了要删除的结点
            if (root.left!=null&&root.right!=null){
                // 删除的结点是双分支结点
                // 获取right子树的最小值
                Node rightMin = root.right;
                while (rightMin.left!=null){
                    rightMin = rightMin.left;
                }
                //替换
                root.value = rightMin.value;
                // 接下来, 去right子树上删除rightMin(此时rightMin一定不是双分支结点)
                // 递归调用删除方法, 在这个root的right子树上删除这个替换值
                root.right = removeByRe(root.right,root.value);
                return root;
            }
            // 删除的是叶子或者单分支
            Node node = root.left != null? root.left : root.right;
            size--;
            return node;
        }
    }
    //非递归方法删除二叉搜索树结点
    public boolean removeByNonRecursive(T value) {
        //不存储null: null不能比较大小
        if (value == null)
            throw new IllegalArgumentException("The param is null");
        
        Node index = root;
        Node indexF = null;
        int com;
        while (index != null) {
            com = value.compareTo(index.value);
            if (com > 0) {
                indexF = index;
                index = index.right;
            } else if (com < 0) {
                indexF = index;
                index = index.left;
            } else
                break;
        }
        // indexF 是要删除结点的父结点
        // index 是找到的要删除的结点

        //如果index是null,没有包含删除的元素，返回false
        if (index == null)
            return false;

        //到这里，说明包含需要删除的元素
        if (index.left != null && index.right != null) {
            //去right子树找一个最小值, 替换这个删除结点
            Node rightMin = index.right;
            //替换结点的父结点
            Node rightMinF = index;
            //找index.right子树的最小值, 最left的元素
            while (rightMin.left != null) {
                rightMinF = rightMin;
                rightMin = rightMinF.left;
            }

            //到达这里：rightMin.left=null
            //用查找的right子树上的最小值, 替换这个要删除的双分支结点
            index.value = rightMin.value;
            //将替换结点设置为后面需要删除的单分支结点
            indexF = rightMinF;
            index = rightMin;
        }

        // 有可能原本就是叶子或者单分支
        // 也有可能双分支已经替换了, 现在要删除的是哪个替换了的, 叶子或者单分支

        // 必定是个叶子或者单分支: index
        // 同时我们还记录了index 的 父结点 indexF

        //寻找index的儿子结点ch:
        // 如果index是叶子 ,那么ch = null
        // 如果index是单分支, ch = 不为null单分支子结点
        Node ch = index.left != null ? index.left : index.right;

        // 如果删除的是根节点, 并且根节点还是个单分支的结点, 对于上述代码会导致midF = null
        if (indexF == null) {
            root = ch;
            size--;
            return true;
        }

        //删除结点
        if (indexF.left == index) {
            indexF.left = ch;
        } else
            indexF.right = ch;
        size--;
        return true;
    }

    //用栈来实现先中后序遍历：
    //①先序
    public List<T> preOrder() {
        //保存遍历结果
        List<T> list = new ArrayList<>();
        //用栈来临时存储结点
        MyLinkedStack<Node> stack = new MyLinkedStack<>();
        //根节点入栈
        stack.push(root);
        while (!stack.isEmpty()) {
            Node pop = stack.pop();
            list.add(pop.value);
            if (pop.right != null)
                stack.push(pop.right);
            if (pop.left != null)
                stack.push(pop.left);
        }
        return list;
    }

    //②中序
    public List<T> inOrder() {
        Stack<Node> stack = new Stack<>();
        List<T> list = new ArrayList<>();
        Node index = root;
        while (index != null || !stack.empty()) {
            while (index != null) {
                stack.push(index);
                index = index.left;
            }
            Node pop = stack.pop();
            list.add(pop.value);
            index = pop.right;
        }
        return list;
    }

    //③后序
    public List<T> postOrder() {
        Stack<Node> stack = new Stack<>();
        List<T> list = new ArrayList<>();
        stack.push(root);
        while (!stack.empty()) {
            Node pop = stack.pop();
            list.add(0, pop.value);
            if (pop.left != null)
                stack.push(pop.left);
            if (pop.right != null)
                stack.push(pop.right);
        }
        return list;
    }

    //用递归来实现先中后序遍历
    //①先序
    public List<T> preOrderRecursive() {
        List<T> list = new LinkedList<>();
        preRecursive(list, root);
        return list;
    }

    // 先序：根 左 右
    private void preRecursive(List<T> list, Node node) {
        if (node == null)
            return;
        list.add(node.value);
        preRecursive(list, node.left);
        preRecursive(list, node.right);
    }

    //②中序
    public List<T> inOrderRecursive() {
        List<T> list = new LinkedList<>();
        inRecursive(list, root);
        return list;
    }

    // 中序遍历： 左 根 右
    private void inRecursive(List<T> list, Node node) {
        if (node == null)
            return;
        inRecursive(list, node.left);
        list.add(node.value);
        inRecursive(list, node.right);
    }

    //③ 后序遍历
    public List<T> postOrderRecursive() {
        List<T> list = new LinkedList<>();
        postRecursive(list, root);
        return list;
    }

    // 后序： 左 右 根
    private void postRecursive(List<T> list, Node node) {
        if (node == null)
            return;
        preRecursive(list, node.left);
        preRecursive(list, node.right);
        list.add(node.value);
    }

    // 层级： 广度优先搜索(BFS)
    public List<T> levOrder() {
        List<T> list = new ArrayList<>();
        Queue<Node> queue = new LinkedBlockingQueue<>();

        //根节点入队列
        queue.offer(root);
        while (!queue.isEmpty()) {
            //出队列元素
            Node poll = queue.poll();
            //遍历
            list.add(poll.value);
            //把出队列元素的左右子节点入队列
            if (poll.left != null)
                queue.offer(poll.left);
            if (poll.right != null)
                queue.offer(poll.right);
        }
        return list;
    }


    //  建树: 给定前中序, 或者给定中后序,  构建出一棵二叉树


    //  中序 [-50, -25, -20, -10, -5, 1, 2, 7, 10, 25, 30, 100]
    //  后序 [-20, -25, -50, -10, -5, 7, 2, 25, 30, 100, 10, 1]
    public Node buildTreeByInAndPostOrder(List<T> inOrder, List<T> postOrder) {
        Node treeRoot = buildTreeByInAndPostOrder2(inOrder, postOrder);
        return treeRoot;
    }

    private Node buildTreeByInAndPostOrder2(List<T> inOrder, List<T> postOrder) {
        if (inOrder.size() == 0) return null;
        if (inOrder.size() == 1) return new Node(inOrder.get(0), null, null);
        //找根结点: 后序的最后一个元素
        T rootValue = postOrder.get(postOrder.size() - 1);
        //获得根节点在中序的位置
        int rootAtInOrderIndex = inOrder.indexOf(rootValue);

        // 左子树的中序(中序中切割): 0 ~ rootAtInOrderIndex-1
        // 左子树的后序(后序中切割): 0 ~ rootAtInOrderIndex -1

        // 右子树的中序(中序中切割): rootAtInOrderIndex + 1 ~ size -1
        // 右子树的后序(后序中切割): rootAtInOrderIndex ~ size - 2

        //左子树
        //subList()：左闭右开
        List<T> leftInOrder = inOrder.subList(0, rootAtInOrderIndex);
        List<T> leftPostOrder = postOrder.subList(0, rootAtInOrderIndex);

        //右子树
        //subList()：左闭右开
        List<T> rightInOrder = inOrder.subList(rootAtInOrderIndex + 1, inOrder.size());
        List<T> rightPostOrder = postOrder.subList(rootAtInOrderIndex, postOrder.size() - 1);
        //构建这次递归的根节点
        Node node = new Node(rootValue, null, null);
        // 用递归方法处理, 获得左子树
        node.left = buildTreeByInAndPostOrder2(leftInOrder, leftPostOrder);
        // 用递归方法处理, 获得右子树
        node.right = buildTreeByInAndPostOrder2(rightInOrder, rightPostOrder);

        return node;
    }

    //  中序 [-50, -25, -20, -10, -5, 1, 2, 7, 10, 25, 30, 100]
    //  前序 1  -5  -10  -50  -25  -20   10  2  7  100  30  25
    public Node buildTreeByInAndPreOrder(List<T> inOrder, List<T> preOrder) {
        Node treeRoot = buildTreeByInAndPreOrder2(inOrder, preOrder);
        return treeRoot;
    }

    private Node buildTreeByInAndPreOrder2(List<T> inOrder, List<T> preOrder) {
        if (inOrder.size() == 0) return null;
        if (inOrder.size() == 1) return new Node(inOrder.get(0), null, null);

        T rootValue = preOrder.get(0);
        int rootAtInOrderIndex = inOrder.indexOf(rootValue);

        //左子树
        //subList()：左闭右开
        List<T> leftInOrder = inOrder.subList(0, rootAtInOrderIndex);
        List<T> leftPreOrder = preOrder.subList(1, rootAtInOrderIndex + 1);
        //右子树
        //subList()：左闭右开
        List<T> rightInOrder = inOrder.subList(rootAtInOrderIndex+1,inOrder.size());
        List<T> rightPreOrder = preOrder.subList(rootAtInOrderIndex+1,preOrder.size());

        Node node = new Node(rootValue,null,null);
        node.left = buildTreeByInAndPreOrder2(leftInOrder,leftPreOrder);
        node.right = buildTreeByInAndPreOrder2(rightInOrder,rightPreOrder);
        return node;
    }

    //判空
    public boolean isEmpty() {
        return size == 0;
    }

    //返回结点个数
    public int size() {
        return size;
    }

    class Node {
        T value;
        Node left;
        Node right;

        public Node(T value, Node left, Node right) {
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }
}