• 題目：二叉樹的前序遍歷（遞迴以及非遞迴方法）
• 難度：Medium
• 思路：遞迴很簡單，非遞迴需要藉助棧來實現
• 程式碼：
  遞迴程式碼

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    //遞迴方法
    public List<Integer> preorderTraversal
 
(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        if(root == null){
            return result;
        }
        recursion(root,result);
        return result;
    }

    public void recursion(TreeNode node, List<Integer> list){
        if(node == null
 
){
            return;
        }else{
            //先遞迴左子樹，再遞迴右子樹
            list.add(node.val);
            recursion(node.left, list);
            recursion(node.right, list);
        }
    }

}

非遞迴程式碼

public class Solution {
    //遞迴方法
    public List<Integer> preorderTraversal(TreeNode root) {
        List
 
<Integer> result = new ArrayList<Integer>();
        if(root == null){
            return result;
        }
        //利用雙向連結串列做棧使用
        LinkedList<TreeNode> stack = new LinkedList<>();
        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;
    }

}

• 題目：二叉樹的後序遍歷（遞迴與非遞迴方式）
• 難度：Medium
• 思路：後序遍歷的遞迴方式與前序相似，只需要將跟節點的訪問調整到左右子樹訪問之後；而非遞迴
• 程式碼：
  遞迴方法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        recursion(root, result);
        return result;
    }

    public void recursion(TreeNode node, List<Integer> list){
        if(node == null){
            return;
        }else{
            recursion(node.left, list);
            recursion(node.right, list);
            list.add(node.val);
        }
    }
}

非遞迴方法

public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        TreeNode curr = null;
        TreeNode pre = null;
        while(!queue.isEmpty()){
            curr = queue.peekLast();
            //1.當前節點為葉子節點時，該節點需要加入result列表
            //2.上一個訪問的節點是當前節點的左孩子或者右孩子時，說明該節點的左右子樹節點都已經被訪問過，該節點也被加入result列表
            //對於第2點，可能存在疑問：如果當前節點有兩個孩子，應該需要判斷它兩個孩子都被訪問呀？，事實是，我們在入佇列的時候是右孩子先入佇列，然後左孩子再入佇列。curr節點的右孩子等於pre的時候，說明curr節點的左孩子已經被訪問了或者curr節點沒有左孩子；curr節點的左孩子等於pre的時候，說明curr節點只有左孩子
            if((curr.left == null && curr.right == null) || 
                (pre != null &&(curr.left == pre || curr.right == pre))){
                result.add(curr.val);
                pre = queue.pollLast();
            }else{
                if(curr.right != null){
                    queue.offer(curr.right);
                }
                if(curr.left != null){
                    queue.offer(curr.left);
                }
            }
        }
        return result;
    }
}

• 題目：中序遍歷二叉樹（遞迴和非遞迴）
• 難度：Medium
• 思路：遞迴方式遍歷與前後序基本一樣，只是改變訪問根節點的位置；非遞迴方式，我覺得比較難，主要是想統一三種遍歷的程式碼，對中序遍歷來講，這裡使用到一個trick就是將curr.left將入棧之後，就把curr.left設定為null
• 程式碼：
  遞迴

public class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        recursion(root, result);
        return result;
    }
    public void recursion(TreeNode node, List<Integer> list){
        if(node == null){
            return;
        }else{
            recursion(node.left, list);
            list.add(node.val);
            recursion(node.right, list);
        }
    }

}

非遞迴

public class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        TreeNode curr = null;
        while(!queue.isEmpty()){
            curr = queue.peekLast();
            System.out.println("進入while迴圈");
            if(curr.left != null){
                queue.offer(curr.left);
                curr.left = null;//這個trick非常重要，不然就會死迴圈
            }else{
                result.add(curr.val);
                curr = queue.pollLast();
                if(curr.right != null){
                    queue.offer(curr.right);
                }
            }

        }
        return result;
    }

}