Implementing a Stack 2-Ways Fast AF

As a developer, you may have come across the concept of a stack — a data structure that follows the last-in, first-out (LIFO) principle. A stack allows you to push elements onto it and pop them off in the reverse order that they were added. This can be useful in a variety of scenarios, such as implementing an undo feature or maintaining a history of visited pages in a web browser.

There are several ways to build a stack in Swift, each with its own set of benefits and drawbacks. In this tutorial, we will go over three approaches: using an array, using a linked list, and using a stack class.

Option 1: Using an Array

One of the simplest ways to implement a stack is by using an array. Arrays are built-in to Swift and offer fast access to elements, but they can be inefficient when it comes to inserting and deleting items at the beginning or middle of the list.

To build a stack using an array, we can simply define a variable of type [T] where T is the type of elements we want to store in the stack. Here is an example of a stack that stores integers:

var stack: [Int] = []

To add an element to the stack, we can use the append method:

stack.append(5)
stack.append(3)
stack.append(8)

To remove the top element from the stack, we can use the popLast method:

if let last = stack.popLast() {
    print(last) // prints 8
}

To check the top element without removing it, we can access the last property of the array:

if let top = stack.last {
    print(top) // prints 3
}

Option 2: Using a Linked List

Another option for building a stack is to use a linked list. Linked lists are a type of data structure that consists of a sequence of nodes, where each node stores a value and a reference to the next node in the list. Linked lists are more efficient than arrays when it comes to inserting and deleting elements, but they are less efficient for accessing elements by index.

To build a stack using a linked list, we can define a class or struct that represents a node in the list. Here is an example of a node class that stores an integer value:

class Node {
    let value: Int
    var next: Node?
    
    init(value: Int) {
        self.value = value
    }
}

We can then define a stack class that keeps track of the top node of the list and provides methods for pushing and popping elements:

class Stack {
    private var top: Node?
    
    func push(value: Int) {
        let newNode = Node(value: value)
        newNode.next = top
        top = newNode
    }
    
    func pop() -> Int? {
        let currentTop = top
        top = top?.next
        return currentTop?.value
    }
}

To use the stack, we can create an instance and call the push and pop methods:

let stack = Stack()
stack.push(5)