# Binary Tree Preorder Traversal

144. Binary Tree Preorder Traversal

Given a binary tree, return the preorder traversal of its nodes' values.

For example:
Given binary tree {1,#,2,3},

``````   1
\
2
/
3
``````

return [1,2,3].

Note: Recursive solution is trivial, could you do it iteratively?

``````class Solution {
func preorderTraversal(_ root: TreeNode?) -> [Int] {
var result: [Int] = []

helper(root, &result)

return result
}

func helper(_ root: TreeNode?, _ result: inout [Int]) {
guard let root = root else {
return
}

result.append(root.val)

helper(root.left, &result)
helper(root.right, &result)
}
}
``````
``````/**
* Definition for a binary tree node.
* public class TreeNode {
*     public var val: Int
*     public var left: TreeNode?
*     public var right: TreeNode?
*     public init(_ val: Int) {
*         self.val = val
*         self.left = nil
*         self.right = nil
*     }
* }
*/
class Solution {
func preorderTraversal(_ root: TreeNode?) -> [Int] {
guard let root = root else {
return []
}

var result: [Int] = []

var stack: [TreeNode] = []
stack.append(root)

while !stack.isEmpty {
let node = stack.removeLast()
result.append(node.val)

if let right = node.right {
stack.append(right)
}
if let left = node.left {
stack.append(left)
}
}

return result
}
}
``````
``````/**
* 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<>();
if (root == null) {
return result;
}

Stack<TreeNode> stack = new Stack<>();
stack.push(root);

while (!stack.isEmpty()) {
TreeNode node = stack.pop();

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

return result;
}
}
``````

Hope this helps,
Michael