【LintCode 題解】騰訊算法面試題：二叉樹的前序遍歷

題目描述

給出一棵二叉樹，返回其節點值的前序遍歷。

• 首個數據爲根節點，後面接着是其左兒子和右兒子節點值，"#"表示不存在該子節點。

• 節點數量不超過20

樣例 1:

輸入：{1,2,3}
輸出：[1,2,3]
解釋：
   1
  / \
 2   3
它將被序列化爲{1,2,3}
前序遍歷

樣例 2:

輸入：{1,#,2,3}
輸出：[1,2,3]
解釋：
1
 \
  2
 /
3
它將被序列化爲{1,#,2,3}
前序遍歷

題解

非遞歸方式實現前序遍歷時，首先存入當前節點值，然後先將右兒子壓入棧中，再將左兒子壓入棧中。對棧中元素遍歷訪問。

國內大廠面試除了操作系統和計算機網絡這些基礎外，還需要熟練掌握算法和數據結構。自己刷題來準備的話至少需要3個月的時間，當然通過算法課程，一般能節省大把時間，快的話一個月時間就能應對大廠算法面試。

Version 0: Non-Recursion (Recommend)
/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        List<Integer> preorder = new ArrayList<Integer>();
        
        if (root == null) {
            return preorder;
        }
        
        stack.push(root);
        while (!stack.empty()) {
            TreeNode node = stack.pop();
            preorder.add(node.val);
            if (node.right != null) {
                stack.push(node.right);
            }
            if (node.left != null) {
                stack.push(node.left);
            }
        }
        
        return preorder;
    }
}

//Version 1: Traverse
public class Solution {
    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<Integer>();
        traverse(root, result);
        return result;
    }
    // 把root爲跟的preorder加入result裏面
    private void traverse(TreeNode root, ArrayList<Integer> result) {
        if (root == null) {
            return;
        }

        result.add(root.val);
        traverse(root.left, result);
        traverse(root.right, result);
    }
}

//Version 2: Divide & Conquer
public class Solution {
    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<Integer>();
        // null or leaf
        if (root == null) {
            return result;
        }

        // Divide
        ArrayList<Integer> left = preorderTraversal(root.left);
        ArrayList<Integer> right = preorderTraversal(root.right);

        // Conquer
        result.add(root.val);
        result.addAll(left);
        result.addAll(right);
        return result;
    }
}