二叉树的四种遍历方式（普通实现+力扣实战）

二叉树的四种遍历方式

1.前序遍历
2.中序遍历
3.后序遍历
（前三种都采用递归实现）
4.层序遍历

所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题(比如：打印节点内容、节点内容加1)。
遍历是二叉树上最重要的操作之一，是二叉树上进行其它运算之基础。

前序遍历：ABCDEF
中序遍历：DBAECF
后序遍历：DBEFCA
层序遍历：ABCDEF
总结：遍历路径是一样的，只不过打印时机不一样，才导致了不同的结果。
下面分别用代码来实现，其中包括前三种遍历方式力扣上的实现代码。

1、前序遍历（NLR）

指访问根结点—>根的左子树—>根的右子树。
1.无返回值

void preOrderTraversal(BTNode root) {
        if(root == null) return;
        System.out.print(root.val);
        preOrderTraversal(root.left);
        preOrderTraversal(root.right);
    }

2.力扣

class Solution {
    List<Integer> list = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        
        if(root != null){
            list.add(root.val);
            preorderTraversal(root.left);
            preorderTraversal(root.right);
        }
        return list;
    }
}

2、中序遍历（LNR）

指根的左子树—>根节点—>根的右子树
1.无返回值

void inOrderTraversal(BTNode root) {
        if(root == null) return;
        inOrderTraversal(root.left);
        System.out.print(root.val);
        inOrderTraversal(root.right);
    }

2.力扣

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root != null){
            List<Integer> leftlist = inorderTraversal(root.left);
            list.addAll(leftlist);
            list.add(root.val);
            List<Integer> rightlist = inorderTraversal(root.right);
            list.addAll(rightlist);
        }
        return list;

    }
}

3、后序遍历（LRN）

指根的左子树—>根的右子树—>根节点
1.无返回值

void inOrderTraversal(BTNode root) {
        if(root == null) return;
        inOrderTraversal(root.left);
        System.out.print(root.val);
        inOrderTraversal(root.right);
    }

2.力扣

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
         List<Integer> list = new ArrayList<>();
        if(root != null){
           
            List<Integer> leftlist = postorderTraversal(root.left);
            list.addAll(leftlist);
            List<Integer> rightlist = postorderTraversal(root.right);
            list.addAll(rightlist);
             list.add(root.val);
        }
        return list;
    }
}

4、层序遍历（非递归实现）

设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。
下面用队列这样的数据结构实现非递归的层序遍历。
思路：
1.如果根不为空，就将根入队。
2.判断队列是否为空： 队列不为空：弹出队头元素，保留在cur中并打印。然后判断当前的cur.left 和cur.right是否为空，不为空，将cur.left 和cur.right入队。

void levelOrderTraversal(BTNode root) {
        if (root == null) return;
        Queue<BTNode> queue = new LinkedList<>();
        //此处root！=null
        queue.offer(root);
        while (!queue.isEmpty()) {
            BTNode cur = queue.poll();
            System.out.print(cur.val + " ");
            if (cur.left != null) {
                queue.offer(cur.left);
            }
            if (cur.right != null) {
                queue.offer(cur.right);
            }
        }
    }

此时，代码只是将二叉树层序遍历打印出来，并不知道二叉树的每一层都有什么节点。
下面提供一种另外一种方法，可以知道每一层的元素。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        //每一个list存储的是当前层的元素
        List<List<Integer>> ret = new ArrayList<>();
        if(root == null) return ret;

         Queue<TreeNode> queue = new LinkedList<>();
        //此处root！=null,把根入队
        queue.offer(root);
        
        //每一层都会重新new一个list保存一层的元素
        while (!queue.isEmpty()) {
              //队列不为空，此时队列中的元素就是当前这一层上的元素
             List<Integer> list = new ArrayList<>();  //存放每一层的数据
             int size = queue.size();   //当前队列不为空，有多少个元素，即当前层的元素个数
             while(size > 0 ){
                 TreeNode cur = queue.poll();
                 list.add(cur.val);
                 if (cur.left != null) {
                       queue.offer(cur.left);
                 }
                 if (cur.right != null) {
                     queue.offer(cur.right);
                 }
                size--;
             }
              ret.add(list);
        }
       return ret;
    }
}