Tree Traversal in Swift using Generics

Tree traversal means visiting/accessing each node of a tree.

There are 2 categories of tree traversals.

1. DFT (Depth First Traversal)
2. BFT (Breadth First Traversal)
3. Depth First Traversal (DFT)

First explore a branch before moving to next branch. There are 3 types of DFT. A. Inorder — Left -> Root -> Right B. Preorder — Root -> Left -> Right C. Postorder — Left -> Right -> Root

For example : A tree having Root(“A”), Left(“B”) and Right(“C”). Inorder will be B -> A -> C Preorder will be A -> B -> C Postorder will be B -> C -> A

In today’s topic, we will be focusing on Inorder, Preorder and Postorder Traversals. Let’s dive into the code.

Here, we have a Tree with nodes(Generics).

import SwiftUI

struct BinaryTreeDashboard: View {
    @StateObject private var viewModel = TreeView<Int>()

    init() {
        let root = TreeNode(10)
        root.left = TreeNode(5)
        root.right = TreeNode(15)
        root.left?.left = TreeNode(2)
        root.left?.right = TreeNode(8)
        root.right?.left = TreeNode(12)
        root.right?.right = TreeNode(20)

        _viewModel = StateObject(wrappedValue: {
            let vm = TreeView<Int>()
            vm.root = root
            return vm
        }())
    }

    var body: some View {
        VStack(spacing: 30) {
            Text("Tree Visualizer").font(.largeTitle.bold())

            // 1. THE VISUAL TREE
            if let root = viewModel.root {
                RecursiveTreeRow(node: root, resultSet: viewModel.traversalResult)
                    .padding()
                    .background(RoundedRectangle(cornerRadius: 15).fill(Color.gray.opacity(0.05)))
            }

            // 2. CONTROLS
            HStack {
                Button("Pre-order") { viewModel.runTraversal(.preOrder) }
                Button("In-order") { viewModel.runTraversal(.inOrder) }
                Button("Post-order") { viewModel.runTraversal(.postOrder) }
            }
            .buttonStyle(.borderedProminent)

            // 3. TEXT OUTPUT
            VStack(alignment: .leading) {
                Text("Traversal Sequence:").font(.headline)
                Text(viewModel.traversalResult.isEmpty ? "Select a mode" :
                     viewModel.traversalResult.map { "\($0)" }.joined(separator: " → "))
                    .font(.system(.title3, design: .monospaced))
                    .foregroundColor(.blue)
            }
            Spacer()
        }
        .padding()
    }
}

// Recursive Component to Draw the Tree
struct RecursiveTreeRow: View {
    let node: TreeNode<Int>
    let resultSet: [Int]

    var body: some View {
        VStack(spacing: 20) {
            // Node Circle
            Text("\(node.value)")
                .font(.headline)
                .foregroundColor(.white)
                .frame(width: 40, height: 40)
                .background(Circle().fill(resultSet.contains(node.value) ? Color.blue : Color.gray))
                .shadow(radius: 2)

            // Children Row
            HStack(alignment: .top, spacing: 20) {
                if let left = node.left {
                    RecursiveTreeRow(node: left, resultSet: resultSet)
                }
                if let right = node.right {
                    RecursiveTreeRow(node: right, resultSet: resultSet)
                }
            }
        }
    }
}

// Preview provider for the SwiftUI canvas
#Preview {
    BinaryTreeDashboard()
}

We need a TreeView Model.

import SwiftUI
import Combine

// Generic Tree Node
class TreeNode<T> {
    var value: T
    var left: TreeNode?
    var right: TreeNode?

    init(_ value: T) {
        self.value = value
    }
}

// Traversal Logic
enum TraversalType {
    case inOrder, preOrder, postOrder
}

class TreeView<T>: ObservableObject {
    @Published var traversalResult: [T] = []
    var root: TreeNode<T>?

    func runTraversal(_ type: TraversalType) {
        traversalResult = [] // Clear previous results
        switch type {
        case .inOrder:
            inOrder(root)
        case .preOrder:
            preOrder(root)
        case .postOrder:
            postOrder(root)
        }
    }

    private func inOrder(_ node: TreeNode<T>?) {
        guard let node = node else { return }
        inOrder(node.left)
        traversalResult.append(node.value)
        inOrder(node.right)
    }

    private func preOrder(_ node: TreeNode<T>?) {
        guard let node = node else { return }
        traversalResult.append(node.value)
        preOrder(node.left)
        preOrder(node.right)
    }

    private func postOrder(_ node: TreeNode<T>?) {
        guard let node = node else { return }
        postOrder(node.left)
        postOrder(node.right)
        traversalResult.append(node.value)
    }
}

The output will be:

Hope this helps you to understand how the tree traversals works with Generics. Happy Coding!