二叉树的前序、中序、后序、层次、之字形层次遍历

二叉树的遍历
*  遍历方式：中序遍历 左-根-右
*          前序遍历 根-左-右
*          后序遍历 左-右-根
*          层次遍历 从上往下遍历
*  遍历常考算法题与实现思路：
*      ①求二叉树的层次遍历：对于不为空的结点，先把该结点加入到队列中；从队中拿出结点，如果该结点的左右结点不为空，
*                         就分别把左右结点加入到队列中；重复以上操作直到队列为空。
*      ②求二叉树的之字形层次遍历：与层次遍历类似，但是偶数层需要倒序输出。可以在原层次遍历的基础上添加一个层数是否为偶数的判断

package tree;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Queue;

/**
 * @author Eightn0
 * @create 2021-03-31 20:06
 * 二叉树的遍历
 *  遍历方式：中序遍历 左-根-右
 *          前序遍历 根-左-右
 *          后序遍历 左-右-根
 *          层次遍历 从上往下遍历
 *  遍历常考算法题与实现思路：
 *      ①求二叉树的层次遍历：对于不为空的结点，先把该结点加入到队列中；从队中拿出结点，如果该结点的左右结点不为空，
 *                         就分别把左右结点加入到队列中；重复以上操作直到队列为空。
 *      ②求二叉树的之字形层次遍历：与层次遍历类似，但是偶数层需要倒序输出。可以在原层次遍历的基础上添加一个层数是否为偶数的判断
 *
 */
public class TreeTraversal {
    class TreeNode{
        int value;
        TreeNode left_Node;
        TreeNode right_Node;

        public TreeNode(int value) {
            this.value = value;
            this.left_Node = null;
            this.right_Node = null;
        }
    }

    class BineryTree{
        public tree.TreeNode rootNode;//根节点
        //构造函数
        public BineryTree(int[] data) {
            for (int i = 0; i < data.length; i++) {
                Add_Node_To_Tree(data[i]);
            }
        }
        //将指定的值加入到二叉树中适当的节点
        void Add_Node_To_Tree(int value){
            tree.TreeNode currentNode = rootNode;
            if (rootNode == null){//建立树根
                rootNode = new tree.TreeNode(value);
                return;
            }
            //建立二叉树
            while (true){
                if (value < currentNode.value){//在左子树
                    if (currentNode.left_Node == null){
                        currentNode.left_Node = new tree.TreeNode(value);
                        return;
                    }else currentNode = currentNode.left_Node;
                }else {//在右子树
                    if (currentNode.right_Node == null){
                        currentNode.right_Node = new tree.TreeNode(value);
                        return;
                    }else currentNode = currentNode.right_Node;
                }
            }
        }

    }

    //中序遍历
    public void inOrder(TreeNode node){
        if (node != null){
            inOrder(node.left_Node);
            System.out.println("["+node.value+"]");
            inOrder(node.right_Node);
        }
    }

    //前序遍历
    public void preOrder(TreeNode node){
        if (node != null){
            System.out.println("["+node.value+"]");
            preOrder(node.left_Node);
            preOrder(node.right_Node);
        }
    }

    //后序遍历
    public void postOrder(TreeNode node){
        if (node != null){
            postOrder(node.left_Node);
            postOrder(node.right_Node);
            System.out.println("["+node.value+"]");
        }
    }

    //层次遍历
    public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
        if (root == null) return result;//判断二叉树是否空
        Queue<TreeNode> queue = new ArrayDeque<>();//造一个队列用于执行bfs算法
        queue.offer(root);//将根结点加入队列
                          //offer：添加一个元素并返回true，如果队列已满，则返回false
        while (!queue.isEmpty()) {//处理第一层
            int size = queue.size();
            ArrayList<Integer> curLayer = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode cur = queue.poll();//根节点出队。poll：移除并返问队列头部的元素，如果队列为空，则返回null
                curLayer.add(cur.value);//将根节点的值添加到list中
                if (cur.left_Node != null) {//若左边节点不为空，则入队，直到左边拿完
                    queue.offer(cur.left_Node);
                }
                if (cur.right_Node != null) {//若右边节点不为空，则入队，直到右边拿完
                    queue.offer(cur.right_Node);
                }
            }
            result.add(new ArrayList(curLayer));
        }
        return result;
    }

    /*之字形层次遍历*/
    public ArrayList<ArrayList<Integer>> zigzagLevelOrder (TreeNode root) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
        if (root == null) return result;//判断二叉树是否空
        Queue<TreeNode> queue = new ArrayDeque<>();//造一个队列用于执行bfs算法
        boolean reverse = false;//造一个布尔型变量用于控制偶数层的反转
        queue.offer(root);//将根结点加入队列
        //offer：添加一个元素并返回true，如果队列已满，则返回false
        while (!queue.isEmpty()) {//处理第一层
            int size = queue.size();
            ArrayList<Integer> curLayer = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode cur = queue.poll();//根节点出队。poll：移除并返问队列头部的元素，如果队列为空，则返回null
                curLayer.add(cur.value);//将根节点的值添加到list中
                if (cur.left_Node != null) {//若左边节点不为空，则入队，直到左边拿完
                    queue.offer(cur.left_Node);
                }
                if (cur.right_Node != null) {//若右边节点不为空，则入队，直到右边拿完
                    queue.offer(cur.right_Node);
                }
            }
            if (reverse) Collections.reverse(curLayer);
            result.add(new ArrayList(curLayer));
            reverse = !reverse;
        }
        return result;
    }
}