二叉树的遍历

package algorithms;

import util.TreeNode;

import java.util.*;

public class BinaryTree {

    ArrayList<TreeNode> list = new ArrayList<>();
    /**
     * 二叉树的递归前序遍历：
     *  如果根节点为空，什么都不做。否则：
     *  1 访问根节点
     *  2 前序遍历左子树
     *  2 前序遍历右子树
     * */
    public void PreOrder(TreeNode root){
        if (root!=null){
            list.add(root);
            PreOrder(root.getLeft());
            PreOrder(root.getRight());
        }
    }
    /**
     * 二叉树的递归中序遍历：
     *  如果根节点为空，什么都不做。否则：
     *  1 中序遍历左子树
     *  2 访问根节点
     *  3 中序遍历右子树
     * */
    public void InOrder(TreeNode root){
        if (root != null){
            InOrder(root.getLeft());
            list.add(root);
            InOrder(root.getRight());
        }
    }
    /**
     * 二叉树的递归后序遍历：
     *  如果根节点为空，什么都不做。否则：
     *  1 后序遍历左子树
     *  2 后序遍历右子树
     *  3 访问根节点
     * */
    public void PostOrder(TreeNode root){
        if (root!=null){
            PostOrder(root.getLeft());
            PostOrder(root.getRight());
             
        }
    }

    /**
     * 二叉树的非递归前序遍历:
     *  把有右子树的节点入栈
     *  访问根节点 如果结点
     * */
    public void NotRecursionPreOrder(TreeNode root){
        Stack<TreeNode> stack = new Stack<>();
        TreeNode p = root;
        while(p!=null||!stack.empty()){
            if(p!=null){
                list.add(p);
                if (p.getRight()!=null){
                    stack.push(p);
                }
                p = p.getLeft();
            }else {
                p = stack.pop();
                p = p.getRight();
            }

        }
    }

    /**
     * 二叉树的非递归中序遍历：
     *  借助栈
     * */
    public void NotRecursionInOrder(TreeNode root){
        Stack<TreeNode> stack = new Stack<>();
        TreeNode p = root;
        while (p!=null || !stack.empty()){
            if (p!=null){
                stack.push(p);
                p = p.getLeft();
            }else {
                p = stack.pop();
                list.add(p);
                p = p.getRight();
            }

        }
    }
    /**
     *  二叉树的非递归后序遍历
     *  思路:两个栈(stack,hasLeftChild)，stack用来存放所有节点(依次pop出来就是后序遍历的结果)，hasLeftChild用来存放有左孩子的节点。
     *  开始时，指针p指向根节点，入stack，若左孩子不为空，入hasLeftChild；指针p指向p的右孩子；重复以上。从的节点同时也入hasLeftChild栈。
     *  当p指针为空，则hasLeftChild.pop()，指针指向其左孩子，重复之前的步骤；到所有节点检查完毕，依次弹出stack序列。
     * */
    public void  NotRecurisionPostOrder(TreeNode root){

        Stack<TreeNode> stack = new Stack<>();
        Stack<TreeNode> hasLeftChild = new Stack<>();
        TreeNode p = root;
        while (p!=null||hasLeftChild.empty()){
            if (p!=null){
                stack.push(p);
                if (p.getLeft()!=null){
                    hasLeftChild.push(p);
                }
                p = p.getRight();
            }else {
                p = hasLeftChild.pop().getLeft();
            }
        }
        while (!stack.empty()){
            list.add(stack.pop());
        }
    }
    /**
     * 二叉树的层次遍历：
     *  借助队列：若根节点为空，什么都不做；否则
     *  1 根节点入队。然后出队，访问该节点。
     *  2 然后左子树根节点入队，右子树根节点入队（如果有）；出队，依次访问。
     *  3 重复以上。
     * */
    public void LevelOrder(TreeNode root){
        Queue<TreeNode> queue = new LinkedList<>();
        TreeNode p = root;
        queue.add(p);
        while (p!=null || !queue.isEmpty()){
            p = queue.poll();
            list.add(p);
            if (p.getLeft()!=null){
                queue.add(p.getLeft());
            }
            if(p.getRight()!=null){
                queue.add(p.getRight());
            }
        }
    }
}