二分搜索树的部分方法的实现

创建树

    private class Node {
        T val;
        // 左孩子
        Node left;
        // 右孩子
        Node right;

        public Node(T val) {
            this.val = val;
            this.left = null;
            this.right = null;
        }
    }

前序遍历：中间结点,左结点,右结点

代码实现

    // 前序遍历    中 左 右
    public List<T> preTraverse() {
        List<T> list = new ArrayList<>();
        preTraverse(root, list);
        return list;
    }

    private void preTraverse(Node node, List<T> list) {
        // 递归终止的条件
        if (node == null) {
            return;
        }
        // 递归操作
        list.add(node.val);
        preTraverse(node.left, list);
        preTraverse(node.right, list);

    }

中序遍历：左结点,中间结点,右结点

    // 中序遍历
    public List<T> midTraverse() {
        List<T> list = new ArrayList<>();
        midTraverse(root, list);
        return list;
    }

    private void midTraverse(Node node, List<T> list) {
        // 递归终止条件
        if (node.val == null) {
            return;
        }
        // 递归操作
        midTraverse(node.left, list);
        list.add(node.val);
        midTraverse(node.right, list);
    }

后序遍历：左结点,右结点,中间结点

      // 后序遍历    
    public List<T> afterTraverse() {
        List<T> list = new ArrayList<>();
        afterTraverse(root, list);
        return list;
    }

    private void afterTraverse(Node node, List<T> list) {
        // 递归终止条件
        if (node.val == null) {
            return;
        }
        // 递归操作
        afterTraverse(node.left, list);
        afterTraverse(node.right, list);
        list.add(node.val);
    }

层序遍历：从顶点开始，每层依次输出

    // 层序遍历
    public List<T> levelTraver() {
        List<T> list = new ArrayList<>();
        Queue<Node> queue = new LinkedList<>();
        if (this.root != null) {
            queue.offer(this.root);
        }
        while (!queue.isEmpty()) {
            Node temp = queue.poll();
            list.add(temp.val);
            if (temp.left != null) {
                queue.offer(temp.left);
            }
            if (temp.right != null) {
                queue.offer(temp.right);
            }
        }
        return list;
    }

寻找树中最大值

    // 寻找最大元素所在的结点
    public Node findMaxNode() {
        if (root == null) {
            return null;
        }
        Node cur = root;
        while (cur.right != null) {
            cur = cur.right;
        }
        return cur;
    }

 递归方法实现寻找最大元素:

    // 递归方法寻找最大元素所在的结点
    public Node findMaxNodeDG() {
        if (root == null) {
            return null;
        }
        return findMaxNodeDG(root);
    }

    private Node findMaxNodeDG(Node node) {
        // 递归终止条件
        if (root.right == null) {
            return node;
        }
        // 递归操作
        return findMaxNodeDG(node.right);
    }

寻找树中最小值

    // 寻找最小元素所在的结点
    public Node findMinNode() {
        if (root == null) {
            return null;
        }
        Node cur = root;
        while (cur.left != null) {
            cur = cur.left;
        }
        return cur;
    }

递归方法实现寻找最小元素:

    // 递归方法寻找最小元素所在的结点
    public Node findMinNodeDG() {
        if (root == null) {
            return null;
        }
        return findMinNodeDG(root);
    }

    private Node findMinNodeDG(Node node) {
        // 递归终止条件
        if (root.left == null) {
            return node;
        }
        // 递归操作
        return findMinNodeDG(node.left);
    }