二叉树的遍历方式-递归/非递归/Morris遍历/层序遍历

递归方式

递归遍历较好掌握，仅举例中序遍历方式
二叉树节点数据结构

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;
    }
}

• 中序遍历

List<Integer> list=new LinkedList<>();
//尤其对于递归，要明白这个黑盒函数作用是什么？这个函数就是中序遍历以root为根节点的树
 public void inOrder(TreeNode root) {
       //如果来到了一个空节点，直接返回
        if (root == null) {
        return;
        }
        //当前节点非空，中序遍历以当前节点的左孩子为根节点的树
            inOrder(root.left);
            //左孩子树看完了，回来了，那么才可以把当前的根节点加到list里
            list.add(root.val);
    //中序遍历以当前节点的右孩子为根节点的树
            inOrder(root.right);  
            //再次回来到当前节点的位置
    }

对于一个递归函数，一定要理解好它作用是什么？把它作为一个黑盒去用，不要想着递归几层去理解，另外，代码说明中说了几个回到当前节点的几个位置，值得注意！好递归方式整体好掌握，看看非递归方式

非递归方式

说明一下：非递归方式需要依赖栈结构来存储节点

• 中序遍历(先左-当前-后右)

List<Integer> list=new LinkedList<>();
 public void inorder(TreeNode root) {
        if(root==null){
            return;
        }
            //需要一个栈结构存储节点
            Stack<TreeNode> stack = new Stack<>();
        
            TreeNode cur = root;
            while (!stack.isEmpty() || cur != null) {   //继续条件：栈不空：说明还有节点没处理 或者 当前节点不空说明还有节点没加入栈
                if (cur != null) {
                    //这里是第一次遇到某一个节点，将它加入栈而不处理，因为需要看它的的左孩子树
                    stack.push(cur);
                    cur = cur.left; 
                } else {   //如果当前节点为null，需要回到父节点位置
                    TreeNode node = stack.pop();
                    //这里说明这个node节点的左孩子树已经处理完毕，又回到了该结点，即处理该节点
                    list.add(node.val);
                    //处理完一个节点以后，需要处理其右孩子树
                    cur = cur.right;
                }
            }
    }

• 前序遍历（当前-再左-后右）

 List<Integer> list=new LinkedList<>();
  public void preOreder(TreeNode root) {
        if(root==null){
            return;
        }
            Stack<TreeNode> stack = new Stack<>();
            stack.push(root);
            while (!stack.isEmpty()) {
                TreeNode cur = stack.pop();
                list.add(cur.val);  //直接处理当前节点
                //完毕之后，需要先处理左孩子，再右孩子
                if (cur.right != null) {  //由于栈结构的FIFO性质，先加入右孩子
                    stack.push(cur.right);
                }
                if (cur.left != null) {  //后加入左孩子
                    stack.push(cur.left);
                }
            }
    }

• 后序遍历（先左-再后-当前）

 List<Integer> list=new LinkedList<>();
public void AfterByT(TreeNode root) {
        if(root==null){
            return;
        }
            Stack<TreeNode> stack = new Stack<>();
            stack.push(root);
            TreeNode cur = null;
            TreeNode pre = root;//用一个pre来引用上一个做处理的节点
            while (!stack.isEmpty()) {
                
                cur = stack.peek();
                //  条件1：如果当前节点的左右孩子未作处理（为null的话说明不用处理也即可看做被处理）
                if (cur.left != null && cur.left != pre && cur.right != pre) {
                    //加入左节点到栈中
                    stack.push(cur.left);
                } else if (cur.right != null && pre != cur.right) {//条件2：如果左孩子节点处理了，右节点孩子未作处理
                    stack.push(cur.right);
                } else { //条件3：都已经做了处理或者没有左右节点，就处理当前节点
                    stack.pop();
                    list.add(cur.val);  //处理节点
                    pre = cur;  //更新pre引用
                }
            }
    }

总结一下：迭代的遍历方式，需要栈结构做辅助，存储节点的相对顺序，理解迭代把自己站在当前节点的位置去考虑，自己的左右孩子如何处理，以及和它们的相对处理顺序。

层序遍历

简单介绍一下：层序遍历就是从上到下，从左到右一层一层地处理二叉树

 public void levelSearch(TreeNode root, List<Integer> list) {
       
        if(root==null){
            return;
        }
            Queue<TreeNode> queue = new LinkedList<>();
            queue.add(root);
            while (!queue.isEmpty()) { //记住有时候一次while循环可以做一层的节点处理，如何做？你可以在循环内加一个for循环，这里没这个需求
                //取出并处理当前节点
                TreeNode cur = queue.poll();
                list.add(cur.val);
                // 如果有的话，将该节点的孩子节点加入到队列尾巴上
                if (cur.left != null) {
                    queue.add(cur.left);
                }
                if (cur.right != null) {
                    queue.add(cur.right);
                }
            }
    }

说明：层序遍历需要一个队列结构来存储节点信息

Morris遍历

说明：这个遍历可以实现O（1）的空间复杂度，核心在于这个遍历方式利用了二叉树中叶子节点 的大量的空指针做判断。
核心的判断逻辑：
当前节点为cur
one:如果cur没有左孩子，cur向右移动（cur=cur.right）
two:如果cur有左孩子，找到cur左子树最右的节点，记作maxRight

• 1:如果maxRight的right指针指向空，让其指向cur,cur向左移动（cur=cur.left）
• 2:如果maxRight的right指针指向cur,让其指向空，cur向右移动（cur=cur.right）
  借用一张图来说明具体的使用
  
• cur是节点1，发现该节点有左孩子,它左孩子的最右节点5，由于5节点的右孩子为空，所以让5节点右孩子指向1节点，cur左移动到2
• 2节点有左孩子4，4节点的右孩子为空，让4节点的右孩子指向cur即2节点，cur左移到4
• 4节点没有左孩子，cur右移到2（4节点右孩子指向了2）
• 2节点有左孩子4,4节点的右孩子指向了cur，则让它指向空，cur右移到5
• 5节点不存在左孩子，cur向右移动，在第一步里，5的right指向了1，所以回到了1节点
• cur回到1，左子树遍历完毕，1有左孩子，左子树最右5节点的right指针指向1,1节点向右移动到3,5节点的right指向空
• …
  中序遍历（为例）

  public static void morrisIn(TreeNode head) {
        if(head == null){
            return;
        }
        TreeNode cur = head;
        TreeNode mostRight = null;
        while (cur != null){
            mostRight = cur.left;
            if(mostRight != null){  //当前节点有左孩子
                while (mostRight.right !=null && mostRight.right != cur){
                    mostRight = mostRight.right;
                }  //循环找到左孩子的最右节点前一个节点
                if(mostRight.right == null){  //判断最右节点的值 ，如果为空
                    mostRight.right = cur; //指向cur，向左移动
                    cur = cur.left;
                    continue; //这里直接下一次循环
                }else { //不为空说明
                    mostRight.right = null;
                }
            }
            System.out.print(cur.val+" ");
            cur = cur.right;  //当前节点没有左孩子或者有但cur的左孩子最右节点指向cur
        }
        System.out.println();
    }

总结：

算法题目对二叉树的考查，对二叉树的遍历方式要求很高，懂得其中规律很重要！