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.

Leetcode Binary Tree Preorder Traversal problem solution


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) {
	List<Integer> list = new LinkedList<Integer>();
	Stack<TreeNode> rights = new Stack<TreeNode>();
	while(node != null) {
		list.add(node.val);
		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;
}