LeetCode144. 二叉树的前序遍历

/**
 * Definition for a binary tree node.
 * 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 {
    public List<Integer> preorderTraversal(TreeNode root) {
        if(root == null){
            return new ArrayList<>();
        }

        Stack<TreeNode> stack = new Stack();
        List<Integer> res = new ArrayList();

        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode temp = stack.pop();
            res.add(temp.val);
            if(temp.right != null){
                stack.push(temp.right);
            }

            if(temp.left != null){
                stack.push(temp.left);
            }
        }

        return res;
    }
}

class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []

        stack = []
        res = []

        stack.append(root)
        while len(stack) > 0:
            temp = stack.pop()
            res.append(temp.val)
            if temp.right:
                stack.append(temp.right)

            if temp.left:
                stack.append(temp.left)

        return res

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if(!root){
            return {};
        }

        stack<TreeNode*> st;
        vector<int> res;

        st.push(root);
        while(!st.empty()){
            TreeNode* temp = st.top();
            st.pop();
            res.push_back(temp->val);
            if(temp->right){
                st.push(temp->right);
            }

            if(temp->left){
                st.push(temp->left);
            }
        }

        return res;
    }
};

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func preorderTraversal(root *TreeNode) []int {
    if root == nil{
        return []int{}
    }

    var stack []*TreeNode
    var res []int

    stack = append(stack, root)
    for len(stack) > 0{
        temp := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        res = append(res, temp.Val)
        if temp.Right != nil{
            stack = append(stack, temp.Right)
        }

        if temp.Left != nil{
            stack = append(stack, temp.Left)
        }
    }

    return res
}