# Leetcode Binary Tree Preorder Traversal problem solution

In this Leetcode Binary Tree Preorder Traversal problem solution we have Given the root of a binary tree, return the preorder traversal of its nodes' values.

## Problem solution in Python.

```class Solution:
def preorderTraversal(self, root: TreeNode) -> List[int]:
if not root: return []
preorder_traversal = []
queue = deque([root])
while queue:
current_node = queue.pop()
if not current_node: continue
preorder_traversal.append(current_node.val)
queue.append(current_node.right), queue.append(current_node.left)
return preorder_traversal
```

## Problem solution in Java.

```public List<Integer> preorderTraversal(TreeNode node) {
Stack<TreeNode> rights = new Stack<TreeNode>();
while(node != null) {
if (node.right != null) {
rights.push(node.right);
}
node = node.left;
if (node == null && !rights.isEmpty()) {
node = rights.pop();
}
}
return list;
}
```

## Problem solution in C++.

```class Solution {
public:
vector<int> ans;
void dfs(TreeNode *root){
ans.push_back(root->val);
if(root->left!=NULL){
dfs(root->left);
}
if(root->right!=NULL){
dfs(root->right);
}
}
vector<int> preorderTraversal(TreeNode* root) {
if(root!=NULL){
dfs(root);
}
return ans;
}
};
```

## Problem solution in C.

```int nodeCount(struct TreeNode *root){
if(!root) return 0;
return 1 + nodeCount(root->left) + nodeCount(root->right);
}

void preorderTraverse(struct TreeNode *root, int *i, int *preorder){
if(!root) return;
preorder[*i] = root->val;
(*i)++;
preorderTraverse(root->left, i, preorder);
preorderTraverse(root->right, i, preorder);
}

int* preorderTraversal(struct TreeNode* root, int* returnSize){
*returnSize = nodeCount(root);
int *result = (int *)malloc((*returnSize) * sizeof(int));
int i = 0;
preorderTraverse(root, &i, result);
return result;
}
```