二叉树的创建、遍历（递归、非递归）、求树高（递归、非递归）

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

import static java.lang.Math.max;

public class BiTree {
    public BiTree left;
    public BiTree right;
    public Object data;

    public BiTree(BiTree left, BiTree right, Object data) {
        this.left = left;
        this.right = right;
        this.data = data;
    }

    public BiTree(Object data) {
        this(null, null, data);
    }

    public static BiTree creat(Object[] objs) {
        List<BiTree> dates = new ArrayList<>();
        //将一个数组的值依次转换为Node节点
        for (Object o : objs) {
            dates.add(new BiTree(o));
        }
        //第一个数为根节点
        BiTree root = dates.get(0);
        //建立二叉树
        for (int i = 0; i < objs.length / 2; i++) {
            //左孩子
            dates.get(i).left = dates.get(i * 2 + 1);
            //右孩子
            if (i * 2 + 2 < dates.size()) {
                //避免偶数的时候 下标越界
                dates.get(i).right = dates.get(i * 2 + 2);
            }
        }
        return root;
    }

    public static BiTree creat1(Object[] objs) {
        List<BiTree> dates = new ArrayList<>();
        //将一个数组的值依次转换为Node节点
        for (Object o : objs) {
            dates.add(new BiTree(o));
        }
        //第一个数为根节点
        BiTree root = dates.get(0);
        //建立二叉树
        for (int i = 0; i < objs.length / 2; i++) {
            //左孩子
            dates.get(i).left = dates.get(i * 2 + 1);
            //右孩子
            if (i * 2 + 2 < dates.size()) {
                //避免偶数的时候 下标越界
                dates.get(i).right = dates.get(i * 2 + 2);
            }
        }
        return root;
    }

    //递归遍历：先序中序后序遍历
    //先序遍历
    public static void preOrder(BiTree root) {
        if (root != null) {
            System.out.println(root.data);
            preOrder(root.left);
            preOrder(root.right);
        }
    }

    //中序遍历
    public static void inOrder(BiTree root) {
        if (root != null) {
            inOrder(root.left);
            System.out.println(root.data);
            inOrder(root.right);
        }
    }

    //后序遍历
    public static void afterOrder(BiTree root) {
        if (root != null) {
            afterOrder(root.left);
            afterOrder(root.right);
            System.out.println(root.data);
        }
    }

    //层次遍历
    public static void levelTravel(LinkedList<BiTree> queue, BiTree root) {
        if (root == null) {
            return;
        }
        queue.offer(root);
        while (!queue.isEmpty()) {
            BiTree tree = queue.poll();
            System.out.println(tree.data);
            if (tree.left != null)
                queue.offer(tree.left);
            if (tree.right != null)
                queue.offer(tree.right);
        }
    }

    public static void preTravel(BiTree root) {
        Stack<BiTree> stack = new Stack();
        BiTree p = root;
        while (!stack.empty() || p != null) {
            if (p != null) {
                System.out.println(p.data);
                stack.push(p);
                p = p.left;
            } else {
                p = stack.pop();
                p = p.right;
            }
        }
    }

    /*中序非递归遍历*/
    public static void InTravel(BiTree root) {
        Stack<BiTree> stack = new Stack();
        BiTree p = root;
        while (!stack.empty() || p != null) {
            if (p != null) {
                stack.push(p);
                p = p.left;
            } else {
                p = stack.pop();
                System.out.println(p.data);
                p = p.right;
            }
        }
    }

    public static void afterTravel(BiTree root) {
        Stack<BiTree> stack = new Stack();
        BiTree p = root;
        BiTree r = null;
        while (!stack.empty() || p != null) {
            if (p != null) {
                stack.push(p);
                p = p.left;
            } else {
                p = stack.peek();
                if (p.right != null && p.right != r) {
                    p = p.right;
                    stack.push(p);
                    p = p.left;
                } else {
                    p = stack.pop();
                    System.out.println(p.data);
                    r = p;
                    p = null;
                }
            }
        }
    }

    /**
     * 求树高递归
     *
     * @param root 根节点
     * @return 层高
     */
    public static int level(BiTree root) {
        if (root != null) {
            int l = level(root.left);
            int r = level(root.right);
            return 1 + max(l, r);
        } else {
            return 0;
        }
    }

    /**
     * 求树高，递归法
     *
     * @param root 根节点
     * @return 树高
     */
    public static int level1(BiTree root) {
        if (root == null) {
            return 0;
        }
        int front = -1, rear = -1;
        int last = 0, level_tree = 0;
        BiTree[] queue = new BiTree[100];
        queue[++rear] = root;
        BiTree p;
        while (front < rear) {
            p = queue[++front]; //
            if (p.left != null) {
                queue[++rear] = p.left;
            }
            if (p.right != null) {
                queue[++rear] = p.right;
            }
            //如果当前队头元素是上一层的最后一个结点，就让层数+1，并且last指向新的一层的最后一个结点
            if (front == last) {
                level_tree++;
                last = rear;
            }
        }
        return level_tree;
    }

    public static int level2(BiTree root) {
        if (root == null) {
            return 0;
        }
        int front = -1, rear = -1;
        int level_tree = 0;
        BiTree[] queue = new BiTree[100];
        queue[++rear] = root;
        int count = 0, next_count = 1;
        BiTree p;
        while (front < rear) {
            p = queue[++front]; //元素出队
            count++;
            if (p.left != null) {
                queue[++rear] = p.left; //元素入队
            }
            if (p.right != null) {
                queue[++rear] = p.right;    //元素入队
            }
            if (count == next_count) {
                level_tree++;
                count = 0;
                next_count = rear - front;
            }
        }
        return level_tree;
    }

    public static int level3(BiTree root) {
        if (root == null) {
            return 0;
        }
        LinkedList<BiTree> queue = new LinkedList();
        BiTree p;
        queue.offer(root);
        int count = 0, next_count = 1, level_tree = 0;
        while (!queue.isEmpty()) {
            p = queue.poll();//元素出队
            if (p.left != null) {
                queue.offer(p.left);//元素入队
            }
            if (p.right != null) {
                queue.offer(p.right);//元素入队
            }
            count++;
            if (count == next_count) {
                level_tree++;
                count = 0;
                next_count = queue.size();
            }
        }
        return level_tree;
    }

    public static void level4(BiTree root) {
        if (root == null) {
            return;
        }
        LinkedList<BiTree> queue = new LinkedList();
        BiTree p;
        queue.offer(root);
        while (!queue.isEmpty()) {
            p = queue.poll();//元素出队
            System.out.println(p.data);
            if (p.left != null) {
                queue.offer(p.left);//元素入队
            }
            if (p.right != null) {
                queue.offer(p.right);//元素入队
            }
        }
    }

    public static void main(String[] args) {
        Integer[] a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
        BiTree root = creat(a);
        System.out.println("层次遍历：");
        levelTravel(new LinkedList<>(), root);
        System.out.println("-------------------------------------");
        System.out.println("中序遍历：");
        inOrder(root);
        System.out.println("*************************************");
        InTravel(root);
        System.out.println("-------------------------------------");
        System.out.println("先序遍历：");
        preTravel(root);
        System.out.println("*************************************");
        preOrder(root);
        System.out.println("-------------------------------------");
        System.out.println("后序遍历：");
        afterTravel(root);
        System.out.println("*************************************");
        afterOrder(root);
        System.out.println("-------------------------------------");
        System.out.println("树高：");
        System.out.println(level(root));
        System.out.println(level1(root));
        System.out.println(level2(root));
        System.out.println(level3(root));
        level4(root);
    }
}