notes/OJ notes/pages/Leetcode Binary-Tree-Preorder-Traversal.md

Leetcode Binary-Tree-Preorder-Traversal

2022-07-04 14:51

Algorithms:

#algorithm #DFS #DFS_preorder #Morris_traversal

Data structures:

#DS #binary_tree

Difficulty:

#coding_problem #difficulty-easy

Additional tags:

#leetcode #CS_list_need_understanding

Revisions:

N/A

Related topics:

tag:#DFS

• Leetcode Binary-Tree-Inorder-Traversal
• Leetcode Binary-Tree-Postorder-Traversal
• Leetcode Invert-Binary-Tree
• Leetcode Maximum-Depth-Of-Binary-Tree
• Leetcode Path-Sum
• Leetcode Search-In-a-Binary-Tree
• Leetcode Symmetric-Tree

Links:

• Link to problem

---

Problem

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

Examples

Example 1:

Input: root = [1,null,2,3] Output: [1,2,3]

Example 2:

Input: root = [] Output: []

Example 3:

Input: root = [1] Output: [1]

Constraints

• The number of nodes in the tree is in the range [0, 100].
• -100 <= Node.val <= 100

Thoughts

[!summary] This is a #binary_tree #DFS_preorder problem.

Preorder, means root is at the "Pre" position, so the order is:

• Search root node
• Search left sub-tree
• Search right sub-tree

The recursion version is easy to implement.

Use Stacks for the iteration method, because stacks are FILO, the subtree will get traversed first. And remember to push right subtree first, so that the left one will be traversed first.

The Morris traversal needs more understandings.

Solution

Iteration

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
 * right(right) {}
 * };
 */
class Solution {
public:
  vector<int> preorderTraversal(TreeNode *root) {
    if (!root) {
      return {};
    }

    // Using stacks, since FILO, the latest gets served first.
    vector<int> answer;
    stack<TreeNode *> pending;

    do {
      if (root != nullptr) {
        answer.push_back(root->val);
        // nothing gets pushed if is nullptr;
        pending.push(root->right);
        pending.push(root->left);
      }
      root = pending.top();
      pending.pop();
    } while (root || !pending.empty());

    return answer;
  }
};

Recursion, using private funcs:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
 * right(right) {}
 * };
 */
class Solution {
public:
  vector<int> preorderTraversal(TreeNode *root) {
    // Use two functions:
    vector<int> answer;
    preorder(root, answer);
    return answer;
  }

private:
  void preorder(TreeNode *root, vector<int> &answer) {
    if (root == nullptr) {
      return;
    }

    answer.push_back(root->val);
    preorder(root->left, answer);
    preorder(root->right, answer);
  }
};

Recursion:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
 * right(right) {}
 * };
 */
class Solution {
public:
  vector<int> preorderTraversal(TreeNode *root) {
    // If the node is empty
    if (root == nullptr) {
      return {};
    }
    // First check root
    vector<int> answer;

    answer.push_back(root->val);

    vector<int> left = preorderTraversal(root->left);
    answer.insert(answer.end(), left.begin(), left.end());

    vector<int> right = preorderTraversal(root->right);
    answer.insert(answer.end(), right.begin(), right.end());

    return answer;
  }
};