二叉树的前序、中序、后序、层序遍历

一、二叉树的遍历

前序遍历：先输出父节点，再遍历左子树和右子树 简称中左右
中序遍历：先遍历左子树，再输出父节点，再遍历右子树 简称左中右
后序遍历：先遍历左子树，再遍历右子树，最后输出父节点 简称左右中

前序遍历实现

递归实现

首先将根节点存入数组中然后递归遍历左子树，左子树遍历完之后再遍历右子树，当结点为空时返回结果

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @return int整型一维数组
     */
    public void dfs(List<Integer>  res, TreeNode root) {
          if(root == null)
            return;
        res.add(root.val);
        dfs(res, root.left);
        dfs(res, root.right);
    }
    public int[] preorderTraversal (TreeNode root) {
        // write code here
        List<Integer> list = new ArrayList();
        dfs(list, root);
        int[] res = new int[list.size()];
        for (int i = 0; i < list.size(); i++)
            res[i] = list.get(i);
        return res;
    }
}

如果不使用递归的方式实现 我们可以使用栈的方式来实现

非递归方式实现

首先定义一个栈，然后将根节点首先存入栈中，同时也存入集合中，前序遍历是中左右，而栈是先进后出的数据结构，所以我们要先把右节点入栈，再把左节点入栈，这样取栈中元素时会优先取到左节点，取出来的同时将其存入集合，再将左节点的左右结点存入栈便可，直至栈中元素全为空。

import java.util.*;

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int val) {
        this.val = val;
    }
}

public class PreorderTraversal {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }

        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);

        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            result.add(node.val);

            if (node.right != null) {
                stack.push(node.right);
            }
            if (node.left != null) {
                stack.push(node.left);
            }
        }

        return result;
    }
}

中序遍历实现

public class Solution {
    public void inorder(List<Integer> list, TreeNode root){
        //遇到空节点则返回
        if(root == null)
            return;
        //先去左子树
        inorder(list, root.left);
        //再访问根节点
        list.add(root.val);
        //最后去右子树
        inorder(list, root.right);
    }
     
    public int[] inorderTraversal (TreeNode root) {
        //添加遍历结果的数组
        List<Integer> list = new ArrayList();
        //递归中序遍历
        inorder(list, root);
        //返回的结果
        int[] res = new int[list.size()];
        for(int i = 0; i < list.size(); i++)
            res[i] = list.get(i);
        return res;
    }
}

后序遍历实现

public class Solution {
    public void postorder(List<Integer> list, TreeNode root){
        //遇到空节点则返回
        if(root == null)
            return;
        //先去左子树
        postorder(list, root.left);
        //再去右子树
        postorder(list, root.right);
        //最后访问根节点
        list.add(root.val);
    }
     
    public int[] postorderTraversal (TreeNode root) {
        //添加遍历结果的数组
        List<Integer> list = new ArrayList();
        //递归后序遍历
        postorder(list, root);
        //返回的结果
        int[] res = new int[list.size()];
        for(int i = 0; i < list.size(); i++)
            res[i] = list.get(i);
        return res;
    }
}

层序遍历实现

层序遍历按照顺序先存入集合的结点应该先输出，这符合队列先进先出的概念，首先将根节点放入队列，然后将其左右结点依次放入队列，然后左节点的左右节点又会放入队列但是左节点的左右节点肯定会在右结点之后输出，直至队列为空边就完成了树的层序遍历

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int val) {
        this.val = val;
    }
}

public class LevelOrderTraversal {
    public List<Integer> levelOrder(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            result.add(node.val);

            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }

        return result;
    }
}