【Leecode】代码随想录二叉树篇day14(（前中后&层次）遍历）

二叉树节点构造

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

题目链接：

• 前序：
• 中序：
• 后序：
• 层次：

递归

写递归时抓住三个主要矛盾：

• 递归函数的输入参数&输出返回值
• 递归最终结束的条件
• 处理问题的核心逻辑以及与递归语句的位置

• 我的解法：

前序

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

中序

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

后序

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

一开始还自以为是的加上了两端判空就是截止的语句，其实不加也可通过用例，但是我觉得更有逻辑的说法是遍历函数+输出答案两个函数共同解决。

层次

• 正确解法：

class Solution {
    public List<List<Integer>> resList = new ArrayList<List<Integer>>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        //checkFun01(root,0);
        checkFun02(root);

        return resList;
    }

    public void checkFun01(TreeNode node, Integer deep) {
        if (node == null) return;
        deep++;

        if (resList.size() < deep) {
            //当层级增加时，list的Item也增加，利用list的索引值进行层级界定
            List<Integer> item = new ArrayList<Integer>();
            resList.add(item);
        }
        resList.get(deep - 1).add(node.val);

        checkFun01(node.left, deep);
        checkFun01(node.right, deep);
    }

迭代

前序

class Solution {
    TreeNode[] st = new TreeNode[100];
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if(root == null) return res;
        int idx = 0; TreeNode p = root;
        while(p != null || idx > 0)
        {
            while(p != null)
            {
                res.add(p.val);
                st[idx++] = p;
                p = p.left;
            }
            if(idx > 0){p = st[--idx].right;}
        }
        return res;
    }
}

中序

class Solution {
    //输出中间的位置不同
    public List<Integer> inorderTraversal(TreeNode root) {
        TreeNode[] st = new TreeNode[100];
        List<Integer> res = new ArrayList<Integer>();
        if(root == null) return res;
        TreeNode p = root; int idx = 0;
        while(p != null || idx > 0)
        {
            while(p != null)
            {
                st[idx++] = p;
                p = p.left;
            }
            if(idx > 0) 
            {
                res.add(st[--idx].val);
                p = st[idx].right;
            }
        }
        return res;
    }
}

后序

根据王道的解法，后序依然可以延续上文的解法思路，但是要多添加一个指向当前遍历到的节点p前一个遍历的节点的pre节点来判断是第几次遇到中间节点，这里由于时间关系后续再补代码

class Solution {
   public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        Stack<TreeNode> st = new Stack<>();
        if (root != null) st.push(root);
        while (!st.empty()) {
            TreeNode node = st.peek();
            if (node != null) {
                st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
                st.push(node);                          // 添加中节点
                st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
                if (node.right!=null) st.push(node.right);  // 添加右节点（空节点不入栈）
                if (node.left!=null) st.push(node.left);    // 添加左节点（空节点不入栈）         
                               
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                st.pop();           // 将空节点弹出
                node = st.peek();    // 重新取出栈中元素
                st.pop();
                result.add(node.val); // 加入到结果集
            }
        }
        return result;
   }
}

层次

• 正确解法：

class Solution {
    public List<List<Integer>> resList = new ArrayList<List<Integer>>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        //checkFun01(root,0);
        checkFun02(root);

        return resList;
    }

    public void checkFun02(TreeNode node) {
        if (node == null) return;
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(node);

        while (!que.isEmpty()) {
            List<Integer> itemList = new ArrayList<Integer>();
            int len = que.size();

            while (len > 0) {
                TreeNode tmpNode = que.poll();
                itemList.add(tmpNode.val);

                if (tmpNode.left != null) que.offer(tmpNode.left);
                if (tmpNode.right != null) que.offer(tmpNode.right);
                len--;
            }

            resList.add(itemList);
        }

    }
}