diff --git a/Sources/swift-ds-algorithms/BinaryTree/BreadthFirstSearchValues.swift b/Sources/swift-ds-algorithms/BinaryTree/BreadthFirstSearchValues.swift new file mode 100644 index 0000000..47dcc68 --- /dev/null +++ b/Sources/swift-ds-algorithms/BinaryTree/BreadthFirstSearchValues.swift @@ -0,0 +1,31 @@ +// BreadthFirstSearch.swift +// swift-ds-algorithms +// +// Created by Aaron on 8/16/26. +// Copyright © 2026. All rights reserved. +// + +public enum BreadthFirstSearch { + public static func bfsValues(root: BinaryTreeNode?) -> [Int] { + var values = [Int]() + + guard let root else { + return values + } + + let queue = Queue>() + queue.enqueue(root) + + while let node = queue.deque() { + values.append(node.value) + if let left = node.left { + queue.enqueue(left) + } + if let right = node.right { + queue.enqueue(right) + } + } + + return values + } +} diff --git a/Sources/swift-ds-algorithms/BinaryTree/DepthFirstSearch.swift b/Sources/swift-ds-algorithms/BinaryTree/DepthFirstSearch.swift new file mode 100644 index 0000000..1b89653 --- /dev/null +++ b/Sources/swift-ds-algorithms/BinaryTree/DepthFirstSearch.swift @@ -0,0 +1,51 @@ +// DepthFirstSearch.swift +// swift-ds-algorithms +// +// Created by Aaron on 8/16/26. +// Copyright © 2026. All rights reserved. +// + +public enum DepthFirstSearch { + public static func dfsRecursive(root: BinaryTreeNode?) -> [Int] { + guard let root else { + return [] + } + + var values = [root.value] + + if let left = root.left { + values.append(contentsOf: dfsRecursive(root: left)) + } + + if let right = root.right { + values.append(contentsOf: dfsRecursive(root: right)) + } + + return values + } + + public static func dfs(root: BinaryTreeNode?) -> [Int] { + var values = [Int]() + + guard let root else { + return values + } + + var stack = [root] + + while stack.isEmpty == false { + let node = stack.removeLast() + values.append(node.value) + + if let right = node.right { + stack.append(right) + } + + if let left = node.left { + stack.append(left) + } + } + + return values + } +} diff --git a/Sources/swift-ds-algorithms/BinaryTree/TreeSum.swift b/Sources/swift-ds-algorithms/BinaryTree/TreeSum.swift new file mode 100644 index 0000000..72c90c4 --- /dev/null +++ b/Sources/swift-ds-algorithms/BinaryTree/TreeSum.swift @@ -0,0 +1,43 @@ +// TreeSum.swift +// swift-ds-algorithms +// +// Created by Aaron on 8/17/26. +// Copyright © 2026. All rights reserved. +// + +public enum TreeSum { + public static func treeSumIterative(root: BinaryTreeNode?) -> Int { + var total = 0 + + guard let root else { + return total + } + + var stack = [root] + + while let node = stack.popLast() { + total += node.value + + if let right = node.right { + stack.append(right) + } + + if let left = node.left { + stack.append(left) + } + } + + return total + } + + public static func treeSumRecursive(root: BinaryTreeNode?) -> Int { + guard let root else { + return 0 + } + + var total = root.value + total += treeSumRecursive(root: root.left) + total += treeSumRecursive(root: root.right) + return total + } +} diff --git a/Sources/swift-ds-algorithms/Helpers.swift b/Sources/swift-ds-algorithms/Helpers.swift deleted file mode 100644 index 68a7fff..0000000 --- a/Sources/swift-ds-algorithms/Helpers.swift +++ /dev/null @@ -1,87 +0,0 @@ -// -// Helpers.swift -// swift-algorithmsTests -// -// Created by Aaron on 8/1/17. -// - -import Foundation -import GameKit - -public class Helpers { - public enum HelperError: Error, CustomStringConvertible { - case invalidInput(message: String) - - public var description: String { - switch self { - case .invalidInput(message: let message): - return message - } - } - } - - public static func generateRandomString(ofLength length: Int = 1000000) -> String { - let characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 " - let charCount = characters.count - var wordArray = [Character](repeating: "0", count: length) - let randomGenerator = GKRandomSource.sharedRandom() - - for index in 0.. SinglyLinkedListNode { - let dummyHead = SinglyLinkedListNode(value: 0) - var last = dummyHead - - for index in 0..(from array: [T]) throws -> SinglyLinkedListNode { - var head: SinglyLinkedListNode? - var last: SinglyLinkedListNode? - - for value in array { - let node = SinglyLinkedListNode(value: value) - - if head == nil { - head = SinglyLinkedListNode(value: value) - last = head - } else { - last?.next = node - last = node - } - } - - guard let head else { - throw HelperError.invalidInput(message: "Failed to generate a linked list") - } - - return head - } - - public static func linkedListToArray(head: SinglyLinkedListNode?) -> [T] { - var result: [T] = [] - var current = head - - while let node = current { - result.append(node.value) - current = node.next - } - return result - } -} diff --git a/Sources/swift-ds-algorithms/TestData/BinaryTreeData.swift b/Sources/swift-ds-algorithms/TestData/BinaryTreeData.swift new file mode 100644 index 0000000..a137755 --- /dev/null +++ b/Sources/swift-ds-algorithms/TestData/BinaryTreeData.swift @@ -0,0 +1,88 @@ +// BinaryTree.swift +// swift-ds-algorithms +// +// Created by Aaron on 8/17/26. +// Copyright © 2026. All rights reserved. +// + +public enum BinaryTreeData { + public static func balanced(depth: Int) -> BinaryTreeNode? { + guard depth >= 0 else { return nil } + + let counter = IntegerCounter() + let root = BinaryTreeNode(value: counter.next()) + var currentDepth = 0 + + let queue = Queue>() + queue.enqueue(root) + + while currentDepth < depth { + let count = queue.count + + for _ in 0..(root: BinaryTreeNode?) -> [T] { + return inOrder(node: root) + } + + private static func inOrder(node: BinaryTreeNode?) -> [T] { + var values = [T]() + + guard let node else { + return values + } + + values.append(contentsOf: inOrder(node: node.left)) + values.append(node.value) + values.append(contentsOf: inOrder(node: node.right)) + return values + } + + public static func levelOrderValues(root: BinaryTreeNode?) -> [T] { + var result = [T]() + + guard let root else { + return result + } + + let queue = Queue>() + queue.enqueue(root) + + while let node = queue.deque() { + result.append(node.value) + if let left = node.left { + queue.enqueue(left) + } + if let right = node.right { + queue.enqueue(right) + } + } + + return result + } + + public static func unbalanced() -> BinaryTreeNode { + let c = BinaryTreeNode(value: 3) + let d = BinaryTreeNode(value: 4) + let e = BinaryTreeNode(value: 5) + let a = BinaryTreeNode(value: 1, left: c, right: d) + let b = BinaryTreeNode(value: 2, left: nil, right: e) + let root = BinaryTreeNode(value: 0, left: a, right: b) + return root + } +} diff --git a/Sources/swift-ds-algorithms/TestData/Helpers.swift b/Sources/swift-ds-algorithms/TestData/Helpers.swift new file mode 100644 index 0000000..923023a --- /dev/null +++ b/Sources/swift-ds-algorithms/TestData/Helpers.swift @@ -0,0 +1,36 @@ +// +// Helpers.swift +// swift-algorithmsTests +// +// Created by Aaron on 8/1/17. +// + +import Foundation +import GameKit + +public enum Helpers { + public enum HelperError: Error, CustomStringConvertible { + case invalidInput(message: String) + + public var description: String { + switch self { + case .invalidInput(message: let message): + return message + } + } + } + + public static func generateRandomString(ofLength length: Int = 1000000) -> String { + let characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 " + let charCount = characters.count + var wordArray = [Character](repeating: "0", count: length) + let randomGenerator = GKRandomSource.sharedRandom() + + for index in 0.. Int { + defer { current += 1 } + return current + } +} diff --git a/Sources/swift-ds-algorithms/TestData/SinglyLinkedListData.swift b/Sources/swift-ds-algorithms/TestData/SinglyLinkedListData.swift new file mode 100644 index 0000000..bb0c99b --- /dev/null +++ b/Sources/swift-ds-algorithms/TestData/SinglyLinkedListData.swift @@ -0,0 +1,56 @@ +// SinglyLinkedListData.swift +// swift-ds-algorithms +// +// Created by Aaron on 8/17/26. +// Copyright © 2026. All rights reserved. +// + +public enum SinglyLinkedListData { + + public static func linkedList(ofLength length: Int) -> SinglyLinkedListNode? { + guard length >= 0 else { + return nil + } + + let dummyHead = SinglyLinkedListNode(value: 0) + var last = dummyHead + + for index in 0..(from array: [T]) -> SinglyLinkedListNode? { + var head: SinglyLinkedListNode? + var last: SinglyLinkedListNode? + + for value in array { + let node = SinglyLinkedListNode(value: value) + + if head == nil { + head = SinglyLinkedListNode(value: value) + last = head + } else { + last?.next = node + last = node + } + } + + return head + } + + public static func linkedListToArray(head: SinglyLinkedListNode?) -> [T] { + var result: [T] = [] + var current = head + + while let node = current { + result.append(node.value) + current = node.next + } + return result + } +} diff --git a/Tests/swift-ds-algorithms-tests/BinaryTreeTests/BreadthFirstSearchValuesTests.swift b/Tests/swift-ds-algorithms-tests/BinaryTreeTests/BreadthFirstSearchValuesTests.swift new file mode 100644 index 0000000..934d152 --- /dev/null +++ b/Tests/swift-ds-algorithms-tests/BinaryTreeTests/BreadthFirstSearchValuesTests.swift @@ -0,0 +1,30 @@ +// Test.swift +// swift-ds-algorithms +// +// Created by Aaron on 8/16/26. +// Copyright © 2026. All rights reserved. +// + +import swift_ds_algorithms +import Testing + +struct BreadthFirstValuesTests { + + @Test func testBreadthFirstValues() throws { + var tree = BinaryTreeData.balanced(depth: -1) + var result = BreadthFirstSearch.bfsValues(root: tree) + #expect(result.count == 0) + + tree = BinaryTreeData.balanced(depth: 0) + result = BreadthFirstSearch.bfsValues(root: tree) + #expect(result == [0]) + + tree = BinaryTreeData.balanced(depth: 2) + result = BreadthFirstSearch.bfsValues(root: tree) + #expect(result == [0, 1, 2, 3, 4, 5, 6]) + + tree = BinaryTreeData.unbalanced() + result = BreadthFirstSearch.bfsValues(root: tree) + #expect(result == [0, 1, 2, 3, 4, 5]) + } +} diff --git a/Tests/swift-ds-algorithms-tests/BinaryTreeTests/DepthFirstSearchTests.swift b/Tests/swift-ds-algorithms-tests/BinaryTreeTests/DepthFirstSearchTests.swift new file mode 100644 index 0000000..317bc2d --- /dev/null +++ b/Tests/swift-ds-algorithms-tests/BinaryTreeTests/DepthFirstSearchTests.swift @@ -0,0 +1,48 @@ +// Test.swift +// swift-ds-algorithms +// +// Created by Aaron on 8/16/26. +// Copyright © 2026. All rights reserved. +// + +import swift_ds_algorithms +import Testing + +struct DepthFirstSearchTests { + + @Test func depthFirstSearchRecursive() async throws { + var result = DepthFirstSearch.dfsRecursive(root: nil) + #expect(result == []) + + var root = BinaryTreeNode(value: 1) + result = DepthFirstSearch.dfsRecursive(root: root) + #expect(result == [1]) + + let c = BinaryTreeNode(value: 3) + let d = BinaryTreeNode(value: 4) + let e = BinaryTreeNode(value: 5) + let a = BinaryTreeNode(value: 1, left: c, right: d) + let b = BinaryTreeNode(value: 2, left: nil, right: e) + root = BinaryTreeNode(value: 0, left: a, right: b) + result = DepthFirstSearch.dfsRecursive(root: root) + #expect(result == [0, 1, 3, 4, 2, 5]) + } + + @Test func depthFirstSearch() throws { + var result = DepthFirstSearch.dfs(root: nil) + #expect(result == []) + + var root = BinaryTreeNode(value: 1) + result = DepthFirstSearch.dfs(root: root) + #expect(result == [1]) + + let c = BinaryTreeNode(value: 3) + let d = BinaryTreeNode(value: 4) + let e = BinaryTreeNode(value: 5) + let a = BinaryTreeNode(value: 1, left: c, right: d) + let b = BinaryTreeNode(value: 2, left: nil, right: e) + root = BinaryTreeNode(value: 0, left: a, right: b) + result = DepthFirstSearch.dfs(root: root) + #expect(result == [0, 1, 3, 4, 2, 5]) + } +} diff --git a/Tests/swift-ds-algorithms-tests/BinaryTreeTests/TreeSumTests.swift b/Tests/swift-ds-algorithms-tests/BinaryTreeTests/TreeSumTests.swift new file mode 100644 index 0000000..f60f7bf --- /dev/null +++ b/Tests/swift-ds-algorithms-tests/BinaryTreeTests/TreeSumTests.swift @@ -0,0 +1,34 @@ +// Test.swift +// swift-ds-algorithms +// +// Created by Aaron on 8/17/26. +// Copyright © 2026. All rights reserved. +// + +import swift_ds_algorithms +import Testing + +struct TreeSumTests { + + @Test func testTreeSumIterative() throws { + var root: BinaryTreeNode? + #expect(TreeSum.treeSumIterative(root: root) == 0) + + root = BinaryTreeNode(value: 1) + #expect(TreeSum.treeSumIterative(root: root) == 1) + + root = BinaryTreeData.balanced(depth: 2) + #expect(TreeSum.treeSumIterative(root: root) == 21) + } + + @Test func testTreesumRecursive() throws { + var root: BinaryTreeNode? + #expect(TreeSum.treeSumRecursive(root: root) == 0) + + root = BinaryTreeNode(value: 1) + #expect(TreeSum.treeSumRecursive(root: root) == 1) + + root = BinaryTreeData.balanced(depth: 2) + #expect(TreeSum.treeSumRecursive(root: root) == 21) + } +} diff --git a/Tests/swift-ds-algorithms-tests/LinkedListTests/MergeListsTests.swift b/Tests/swift-ds-algorithms-tests/LinkedListTests/MergeListsTests.swift index 4542889..5aa3c23 100644 --- a/Tests/swift-ds-algorithms-tests/LinkedListTests/MergeListsTests.swift +++ b/Tests/swift-ds-algorithms-tests/LinkedListTests/MergeListsTests.swift @@ -11,10 +11,10 @@ import Testing struct MergeListsTests { @Test func testMergeLists() throws { - var list1: SinglyLinkedListNode? = try Helpers.generateLinkedList(from: [1, 4, 5, 7, 10]) - var list2: SinglyLinkedListNode? = try Helpers.generateLinkedList(from: [0, 3, 6, 8, 10, 11]) + var list1: SinglyLinkedListNode? = SinglyLinkedListData.linkedList(from: [1, 4, 5, 7, 10]) + var list2: SinglyLinkedListNode? = SinglyLinkedListData.linkedList(from: [0, 3, 6, 8, 10, 11]) var result = MergeLists.merge(head1: list1, head2: list2) - var values = Helpers.linkedListToArray(head: result) + var values = SinglyLinkedListData.linkedListToArray(head: result) #expect(values == [0, 1, 3, 4, 5, 6, 7, 8, 10, 10, 11]) list1 = nil @@ -22,10 +22,10 @@ struct MergeListsTests { result = MergeLists.merge(head1: list1, head2: list2) #expect(result == nil) - list1 = try Helpers.generateLinkedList(from: [1, 2, 3]) + list1 = SinglyLinkedListData.linkedList(from: [1, 2, 3]) list2 = nil result = MergeLists.merge(head1: list1, head2: list2) - values = Helpers.linkedListToArray(head: result) + values = SinglyLinkedListData.linkedListToArray(head: result) #expect(values == [1, 2, 3]) } } diff --git a/Tests/swift-ds-algorithms-tests/LinkedListTests/ReverseLinkedListTests.swift b/Tests/swift-ds-algorithms-tests/LinkedListTests/ReverseLinkedListTests.swift index 8219ccc..393262e 100644 --- a/Tests/swift-ds-algorithms-tests/LinkedListTests/ReverseLinkedListTests.swift +++ b/Tests/swift-ds-algorithms-tests/LinkedListTests/ReverseLinkedListTests.swift @@ -19,11 +19,11 @@ struct ReverseLinkedListTest { #expect(result?.value == 0) #expect(result?.next == nil) - head = try Helpers.generateLinkedList(ofLength: 10) + head = SinglyLinkedListData.linkedList(ofLength: 10) result = ReverseLinkedList.reverse(head: head) #expect(result != nil) - let values = Helpers.linkedListToArray(head: result) + let values = SinglyLinkedListData.linkedListToArray(head: result) #expect(values == [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) } @@ -36,11 +36,11 @@ struct ReverseLinkedListTest { #expect(result?.value == 0) #expect(result?.next == nil) - head = try Helpers.generateLinkedList(ofLength: 10) + head = SinglyLinkedListData.linkedList(ofLength: 10) result = ReverseLinkedList.reverseRecursive(head: head) #expect(result != nil) - let values = Helpers.linkedListToArray(head: result) + let values = SinglyLinkedListData.linkedListToArray(head: result) #expect(values == [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) } } diff --git a/Tests/swift-ds-algorithms-tests/LinkedListTests/ZipperListsTests.swift b/Tests/swift-ds-algorithms-tests/LinkedListTests/ZipperListsTests.swift index 5d0240a..fa02864 100644 --- a/Tests/swift-ds-algorithms-tests/LinkedListTests/ZipperListsTests.swift +++ b/Tests/swift-ds-algorithms-tests/LinkedListTests/ZipperListsTests.swift @@ -14,31 +14,31 @@ struct ZipperListsTests { var result = ZipperLists.zipper(head1: nil, head2: nil) #expect(result == nil) - var list1 = try Helpers.generateLinkedList(from: ["a", "b", "c"]) - var list2 = try Helpers.generateLinkedList(from: ["x", "y", "z"]) + var list1 = SinglyLinkedListData.linkedList(from: ["a", "b", "c"]) + var list2 = SinglyLinkedListData.linkedList(from: ["x", "y", "z"]) result = ZipperLists.zipper(head1: list1, head2: list2) - var values = Helpers.linkedListToArray(head: result) + var values = SinglyLinkedListData.linkedListToArray(head: result) #expect(values == ["a", "x", "b", "y", "c", "z"]) - list1 = try Helpers.generateLinkedList(from: ["a", "b", "c"]) - list2 = try Helpers.generateLinkedList(from: ["x", "y"]) + list1 = SinglyLinkedListData.linkedList(from: ["a", "b", "c"]) + list2 = SinglyLinkedListData.linkedList(from: ["x", "y"]) result = ZipperLists.zipper(head1: list1, head2: list2) - values = Helpers.linkedListToArray(head: result) + values = SinglyLinkedListData.linkedListToArray(head: result) #expect(values == ["a", "x", "b", "y", "c"]) - list1 = try Helpers.generateLinkedList(from: ["a", "b"]) - list2 = try Helpers.generateLinkedList(from: ["x", "y", "z"]) + list1 = SinglyLinkedListData.linkedList(from: ["a", "b"]) + list2 = SinglyLinkedListData.linkedList(from: ["x", "y", "z"]) result = ZipperLists.zipper(head1: list1, head2: list2) - values = Helpers.linkedListToArray(head: result) + values = SinglyLinkedListData.linkedListToArray(head: result) #expect(values == ["a", "x", "b", "y", "z"]) - list1 = try Helpers.generateLinkedList(from: ["a", "b", "c"]) + list1 = SinglyLinkedListData.linkedList(from: ["a", "b", "c"]) result = ZipperLists.zipper(head1: list1, head2: nil) - values = Helpers.linkedListToArray(head: result) + values = SinglyLinkedListData.linkedListToArray(head: result) #expect(values == ["a", "b", "c"]) } } diff --git a/Tests/swift-ds-algorithms-tests/TestDataTests/BinaryTreeDataTests.swift b/Tests/swift-ds-algorithms-tests/TestDataTests/BinaryTreeDataTests.swift new file mode 100644 index 0000000..1cf98f3 --- /dev/null +++ b/Tests/swift-ds-algorithms-tests/TestDataTests/BinaryTreeDataTests.swift @@ -0,0 +1,50 @@ +// Test.swift +// swift-ds-algorithms +// +// Created by Aaron on 8/17/26. +// Copyright © 2026. All rights reserved. +// + +import swift_ds_algorithms +import Testing + +struct BinaryTreeDataTests { + + @Test func testBalancedTree() throws { + var tree = BinaryTreeData.balanced(depth: -1) + #expect(tree == nil) + + tree = BinaryTreeData.balanced(depth: 0) + #expect(tree?.value == 0) + + tree = BinaryTreeData.balanced(depth: 2) + let values = BinaryTreeData.levelOrderValues(root: tree) + #expect(values == [0, 1, 2, 3, 4, 5, 6]) + } + + @Test func testInorderValues() { + let root = BinaryTreeNode(value: 0) + let a = BinaryTreeNode(value: 1) + let b = BinaryTreeNode(value: 2) + let c = BinaryTreeNode(value: 3) + root.left = a + root.right = b + b.right = c + + let values = BinaryTreeData.inOrderValues(root: root) + #expect(values == [1, 0, 2, 3]) + } + + @Test func testLevelOrder() { + let root = BinaryTreeNode(value: 0) + let a = BinaryTreeNode(value: 1) + let b = BinaryTreeNode(value: 2) + let c = BinaryTreeNode(value: 3) + root.left = a + root.right = b + b.right = c + + let values = BinaryTreeData.levelOrderValues(root: root) + #expect(values == [0, 1, 2, 3]) + } +} diff --git a/Tests/swift-ds-algorithms-tests/TestDataTests/IntegerCounterTests.swift b/Tests/swift-ds-algorithms-tests/TestDataTests/IntegerCounterTests.swift new file mode 100644 index 0000000..b2dc209 --- /dev/null +++ b/Tests/swift-ds-algorithms-tests/TestDataTests/IntegerCounterTests.swift @@ -0,0 +1,22 @@ +// Test.swift +// swift-ds-algorithms +// +// Created by Aaron on 8/17/26. +// Copyright © 2026. All rights reserved. +// + +import swift_ds_algorithms +import Testing + +struct IntegerCounterTests { + + @Test func testIntegerCounter() throws { + var counter = IntegerCounter() + #expect(counter.next() == 0) + #expect(counter.next() == 1) + + counter = IntegerCounter(start: 5) + #expect(counter.next() == 5) + #expect(counter.next() == 6) + } +} diff --git a/Tests/swift-ds-algorithms-tests/TestDataTests/SinglyLinkedListDataTests.swift b/Tests/swift-ds-algorithms-tests/TestDataTests/SinglyLinkedListDataTests.swift new file mode 100644 index 0000000..04ebf1b --- /dev/null +++ b/Tests/swift-ds-algorithms-tests/TestDataTests/SinglyLinkedListDataTests.swift @@ -0,0 +1,45 @@ +// Test.swift +// swift-ds-algorithms +// +// Created by Aaron on 8/17/26. +// Copyright © 2026. All rights reserved. +// + +import swift_ds_algorithms +import Testing + +struct SinglyLinkedListDataTests { + + @Test func testLinkedList() async throws { + var linkedList = SinglyLinkedListData.linkedList(ofLength: -1) + #expect(linkedList == nil) + + linkedList = SinglyLinkedListData.linkedList(ofLength: 0) + #expect(linkedList == nil) + + linkedList = SinglyLinkedListData.linkedList(ofLength: 10) + let values = SinglyLinkedListData.linkedListToArray(head: linkedList) + #expect(values == Array(0..<10)) + } + + @Test func testLinkedListFromArray() { + var linkedList = SinglyLinkedListData.linkedList(from: [] as [Int]) + #expect(linkedList == nil) + + linkedList = SinglyLinkedListData.linkedList(from: [0]) + #expect(linkedList?.value == 0) + #expect(linkedList?.next == nil) + + linkedList = SinglyLinkedListData.linkedList(from: [1, 2, 3]) + let result = SinglyLinkedListData.linkedListToArray(head: linkedList) + #expect(result == [1, 2, 3]) + } + + @Test func testLinkedListToArray() { + var linkedList = SinglyLinkedListData.linkedList(from: [] as [Int]) + #expect(SinglyLinkedListData.linkedListToArray(head: linkedList) == []) + + linkedList = SinglyLinkedListData.linkedList(from: [1, 2, 3]) + #expect(SinglyLinkedListData.linkedListToArray(head: linkedList) == [1, 2, 3]) + } +}