平衡二叉树

满二叉树：

1，叶子节点在最后一层

2，除过叶子节点 其余非叶子节点都有左右孩子

二分搜索树/二分排序树：

1，当前节点的值大于左节点的值，小于右节点的值

2，每一棵子树也是二分搜索树

注：存储元素的值必须具有可比性

树的遍历：

1，层序遍历

2，中序遍历：按左，根，右方式遍历（二分搜索树的特点：从小到大依次输出）

3，后序遍历：按左，右，根方式遍历

4，先序遍历：按根，左，右方式遍历

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class BSTress<T extends Comparable<T>> {
    class TreeNode<T> {
        T val;//节点的值

        TreeNode<T> left;//左节点->当前节点左孩子
        TreeNode<T> right;//右节点->当前节点右孩子

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

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

    }//树的节点信息

    private TreeNode<T> root;
    private int size;

    //创建二叉搜索树
    public BSTress() {
        this.root = null;
        this.size = 0;
    }
    //前中后序遍历

    //输入节点 生成二叉搜索树
    public void searchTree(T val) {
        this.root = searchTree(root, val);
    }

    private TreeNode<T> searchTree(TreeNode<T> root, T val) {
        //递归终止条件
        if (root == null) {
            this.size++;
            root = new TreeNode<>(val);
            return root;
        }
        //递归操作
        if (root.val.compareTo(val) > 0) {
            root.left = searchTree(root.left, val);
        } else if (root.val.compareTo(val) < 0) {
            root.right = searchTree(root.right, val);
        }
        return root;
    }

    //打印List结果
    public void showList(ArrayList<T> list) {
        if (list == null) {
            return;
        } else {
            list.stream().forEach(item -> {
                System.out.println(item.toString());
            });
        }
    }

    //前序遍历(根 左 右)
    public ArrayList<T> preTravel() {
        ArrayList<T> result = new ArrayList<>();
        preTravel(this.root, result);
        return result;
    }

    private TreeNode<T> preTravel(TreeNode<T> root, ArrayList<T> result) {
        //递归终止条件
        if (root == null) {
            return root;
        }
        //递归操作
        result.add(root.val);
        preTravel(root.left, result);
        preTravel(root.right, result);
        return root;
    }

    //后序遍历(左 右 根)
    public ArrayList<T> sufTravel() {
        ArrayList<T> result = new ArrayList<>();
        sufTravel(this.root, result);
        return result;
    }

    private TreeNode<T> sufTravel(TreeNode<T> root, ArrayList<T> result) {
        //递归终止条件
        if (root == null) {
            return root;
        }
        //递归操作
        sufTravel(root.left, result);
        sufTravel(root.right, result);
        result.add(root.val);
        return root;
    }

    //中序遍历(左 根 右 )
    public ArrayList<T> midTravel() {
        ArrayList<T> result = new ArrayList<>();
        midTravel(this.root, result);
        return result;
    }

    private TreeNode<T> midTravel(TreeNode<T> root, ArrayList<T> result) {
        //递归终止条件
        if (root == null) {
            return root;
        }
        //递归操作
        midTravel(root.left, result);
        result.add(root.val);
        midTravel(root.right, result);
        return root;
    }

    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        BSTress<Integer> bsTress = new BSTress<>();
        for (int i = 0; i < 10; i++) {
            int val = cin.nextInt();
            bsTress.searchTree(val);
        }
        System.out.println("----前序遍历----");
        bsTress.showList(bsTress.preTravel());
        System.out.println("----中序遍历----");
        bsTress.showList(bsTress.midTravel());
        System.out.println("----后序遍历----");
        bsTress.showList(bsTress.sufTravel());
        System.out.println();
    }
}