彻底吃透二叉树的遍历算法

  二叉树是数据结构中最为基础的类型，其变种丰富，如二叉排序树、红黑树、B树、B+树、哈夫曼树等等，其应用场景广泛，如数据压缩、内存管理、文件系统、数据搜索。因此其遍历方法是我们必须要掌握的。
  二叉树最基本的四种遍历分为：先序遍历、中序遍历、后序遍历、层序遍历。这里的顺序是针对根结点而言的，即：
  先序遍历：中左右。先处理根结点–>再处理左子节点–>最后处理右子节点。

如上图所示，先序遍历结果为：ABDFECGHI
  中序遍历：左中右。先处理左子节点–>再处理根结点–>最后处理右子节点。

如上图所示，中序遍历结果为：DBEFAGHCI
  后序遍历：左右中。先处理根结点–>再处理左子节点–>最后处理右子节点。
如上图所示，后序遍历结果为：DEFBHGICA

  层序遍历：从上到下，从左到右，按照层级顺序进行遍历。

如上图所示，层序遍历结果为：【8，3，10，1，6，14，4，7，13】。

  在代码实现时前三种一般采用递归的方式进行，层序遍历采用辅助队列的方式进行，在考试或者面试中遇到这种基本属于送分题，是必须拿下的，下面讲解一下具体的代码实现：
  首先，二叉树的定义为：

  public class TreeNode {
      int val;
      TreeNode left;
      TreeNode right;
      TreeNode() {}
      TreeNode(int val) { this.val = val; }
      TreeNode(int val, TreeNode left, TreeNode right) {
          this.val = val;
          this.left = left;
          this.right = right;
      }
  }

先序遍历

1.添加根结点；
2.递归处理左子树；
3.递归处理右子树。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {     
        List<Integer>res=new ArrayList<>();
        if(root!=null){
            dpPreorder(res,root);
        }
        return res;
    }
    public void dpPreorder(List<Integer>res,TreeNode root){
        //添加根结点
        re.add(root.val);
        //递归处理左子树
        if(root.left!=null){
            dpPreorder(res,root.left);
        }
        //递归处理右子树
        if(root.right!=null){
            dpPreorder(res,root.right);
        }
    }
}

中序遍历

1.递归处理左子树；
2.添加根结点；
3.递归处理右子树。

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {     
        List<Integer>res=new ArrayList<>();
        if(root!=null){
            dpInorder(res,root);
        }
        return res;
    }
    public void dpInorder(List<Integer>res,TreeNode root){
        //递归处理左子树
        if(root.left!=null){
            dpInorder(res,root.left);
        }
        //添加根结点
        re.add(root.val);
        //递归处理右子树
        if(root.right!=null){
            dpInorder(res,root.right);
        }
    }
}

运行该代码解答leetcode第94题

后序遍历

1.递归处理左子树；
2.递归处理右子树；
3.添加根结点。

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {     
        List<Integer>res=new ArrayList<>();
        if(root!=null){
            dpPostorder(res,root);
        }
        return res;
    }
    public void dpPostorder(List<Integer>res,TreeNode root){
        //递归处理左子树
        if(root.left!=null){
            dpPostorder(res,root.left);
        }       
        //递归处理右子树
        if(root.right!=null){
            dpPostorder(res,root.right);
        }
        //添加根结点
        re.add(root.val);
    }
}

层序遍历

1.处理特殊情况，进行空树判断
2.定义队列，将root结点加入队列中；
3.while循环遍历，每次可遍历一个结点也可遍历一层结点，按照题目需求进行选择；每次遍历的操作为：
 ①将队顶元素加入结果集；
 ②将左右子结点加入队列中；
 ③删除队顶元素。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>>res=new ArrayList<>();
        if(root==null)return res;//空树判断
        Queue<TreeNode>nodes=new LinkedList<>();
        nodes.offer(root);//将根结点加入队列
        while(!nodes.isEmpty()){//每次循环遍历一层结点
            List<Integer>temp=new ArrayList<>();
            int size=nodes.size();//for循环中会改变队列的size，因此必须定义变量存一下当前size
            for(int i=0;i<size;i++){
                TreeNode c=nodes.peek();//取队顶元素（不删除）
                temp.add(c.val);
                //将左子结点加入队列
                if(c.left!=null){
                    nodes.offer(c.left);
                }
                //将右子结点加入队列
                if(c.right!=null){
                    nodes.offer(c.right);
                }
                //删除队顶元素
                nodes.poll(); 
            }
            res.add(temp);
        }
        return res;
    }
}

运行该代码解答leetcode第102题：




部分图片转自：https://www.cnblogs.com/du001011/p/11229170.html