java笔试题：二叉树的前中后序遍历+层次遍历（迭代实现）

二叉树的前中后序遍历+层次遍历

• 二叉树的前中后序遍历都是用栈实现，而层次遍历则使用队列实现

一. 二叉树的前序遍历

思路：

• 前序遍历：根左右。也就是先遍历根节点，然后遍历左节点和右节点。
• 由于我们使用的是栈，栈是先入后出的，所以要先压右节点，再加左节点
• 所以我们整个的流程如下：
  • 先入根节点
  • 进入循环 （栈不为空）
  • 出根节点
  • 入右节点，入左节点
  • 循环结束

//前序遍历 根左右 由于使用栈 先入后出 所以要右左入栈 而不是左右
public List<Integer> preorderTraversal(TreeNode root) {

    List<Integer> list = new ArrayList();
    if(root == null) return list;
    Stack<TreeNode> stack = new Stack();
    //入根节点
    stack.push(root);
    while(!stack.isEmpty()){
        //出根节点
        TreeNode node = stack.pop();
        list.add(node.val);
        //入右节点
        if(node.right != null) stack.push(node.right);
        //入左节点
        if(node.left != null ) stack.push(node.left);

    }
    return list;
}

二. 二叉树的中序遍历

思路：

• 中序遍历：左根右。所以每次都需要一直向左将节点压栈，然后出栈，再向右走。
• 这里提供两种思路：实际上两种思路都差不多，但是写法上是有区别的
• 思路一：便于理解和写代码
  • 根节点入栈
  • 进入循环 （栈不为空）
  • 向左遍历，依次将左节点入栈
  • 依次将栈顶没有右孩子的元素出栈，直到找到第一个有右孩子的元素
  • 将该元素出栈，同时将其右孩子入栈
  • 循环结束
• 思路二：代码简洁，但是自己想的话可能不好想，也不好写
  • 进入循环 （ root不为空 或 栈不为空）
  • 将root及所有左孩子入栈（root 不为空）
  • 出栈，但是这里一次只出一个（站不为空）
  • root 转向右节点

这里个人认为思路二的代码简洁性更强，但是不容易想出来和写出来

// 思路一 
public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> list = new ArrayList();
    if(root == null) return list;
    Stack<TreeNode> stack = new Stack();
    stack.push(root);
    while(!stack.isEmpty()){
        //将该节点的所有左节点依次入栈
        while(stack.peek().left != null){
            stack.push(stack.peek().left);
        }
        //依次将没有右子节点的节点出栈
        while(!stack.isEmpty() && stack.peek().right == null){
            list.add(stack.pop().val);
        }
        //最后将第一个有右孩子节点的节点出栈 同时将其右子节点入栈 
        if(!stack.isEmpty()){
            TreeNode node = stack.pop();
            list.add(node.val);
            stack.push(node.right);
        }
    }
    return list;
}


//思路二
public static ArrayList<Integer> postorderTraversal1(TreeNode root) {
    if(root==null){
        return new ArrayList<>();
    }else{
        Stack<TreeNode> stack = new Stack<>();
        ArrayList<Integer> list = new ArrayList<>();
        while (root!=null||!stack.isEmpty()){
            while (root!=null){// 一路向左把沿途结点压入栈
                stack.push(root);
                root = root.left;
            }
            if(!stack.isEmpty()){
                root = stack.pop();// 弹出栈
                list.add(root.val);
                // 转向右节点 如果此时右节点为空，那么接下来就会pop父节点
                root = root.right;
            }
        }
        return list;
    }
}

三.二叉树的后序遍历

• 后序遍历比较复杂，但是看见网上有个比较好记住的办法：按照与前序相似的方法（前序压栈的顺序是先右后左，这里是先左后右），先得到一个结果，然后对结果倒序一下，就可以了。

public static ArrayList<Integer> postorderTraversal2(TreeNode root) {
        if(root == null){
            return new ArrayList<>();
        }else {
            ArrayList<Integer> list = new ArrayList<>();
            Stack<TreeNode> stack = new Stack<>();
            stack.push(root);
            while(!stack.isEmpty()){
                TreeNode tmp = stack.pop();
                list.add(tmp.val);
                if(tmp.left != null) stack.push(tmp.left);
                if(tmp.right != null) stack.push(tmp.right);
            }
            Collections.reverse(list);
            return list;
        }

  }

四. 二叉树的层次遍历

思路：

• 使用队列，先进先出。先遍历层的节点先出。
• 每次将一层的节点入队
• 然后依次出队，每次出队都将其左右孩子入队

public List<Integer> levelOrder(TreeNode root) {
    if(root == null) return new int[0];
    ArrayList<Integer> list = new ArrayList();
    Queue<TreeNode> queue = new LinkedList();
    queue.add(root);
    while(!queue.isEmpty()){
    	//记录这一层有多少节点 依次出队
        int length = queue.size();
        for(int i = 0; i < length; i++){
        	//依次出队
            TreeNode node = queue.poll();
            list.add(node.val);
            //出队之后将左右孩子入队
            if(node.left != null) queue.add(node.left);
            if(node.right != null) queue.add(node.right);
        }
    }
    return list ;
}