Preorder Traversal

Visit the root before each subtree, producing root-left-right order.

Algorithm

The canonical tree is 4(2(1,3),6(5,7)), so this Lua DSA implementation can be compared directly with the rest of the DSA track.

Basic Implementation

basic.lua

local function Node(value, left, right)
  return { value = value, left = left, right = right }
end
local function render(node)
  if node == nil then return "_" end
  if node.left == nil and node.right == nil then return tostring(node.value) end
  return tostring(node.value) .. "(" .. render(node.left) .. "," .. render(node.right) .. ")"
end
local function sample_tree()
  return Node(4, Node(2, Node(1), Node(3)), Node(6, Node(5), Node(7)))
end
local function list_string(values)
  return "[" .. table.concat(values, ", ") .. "]"
end
local function preorder(node, output) if node == nil then return end table.insert(output, node.value); preorder(node.left, output); preorder(node.right, output) end
local output = {}
preorder(sample_tree(), output)
print(list_string(output))

Complexity

Time: O(n)
Space: O(h) recursion stack

Implementation notes

Node(value, left, right) returns a Lua table with value, left, and right fields.
sample_tree() builds the checked tree 4(2(1,3),6(5,7)).
local output = {} is the traversal result table.
preorder(node, output) uses if node == nil then return end as the base case for missing children.
Each non-nil call visits first with table.insert(output, node.value).
The function then recurses into preorder(node.left, output) and finally preorder(node.right, output).
The trace starts with output [], visits root 4, then left subtree nodes 2, 1, and 3, producing [4, 2, 1, 3].
It then visits the right subtree as 6, 5, 7, finishing [4, 2, 1, 3, 6, 5, 7].
print(list_string(output)) renders the final preorder list as [4, 2, 1, 3, 6, 5, 7].

preorder Preorder records the current node before visiting left and right subtrees.