# 1. Introduction

Linear Search is one of the simplest searching algorithms. It works by iterating through the dataset sequentially and checking if the current element matches the target value. If a match is found, the index of the item is returned; otherwise, the algorithm will indicate that the item is not in the dataset.

# 2. Implementation Steps

1. Start from the first element of the dataset.

2. Compare the target value with the current element.

3. If they match, return the index of the current element.

4. If they do not match, move to the next element.

5. Repeat steps 2-4 until the end of the dataset or until a match is found.

# 3. Implementation in Swift

``````func linearSearch<T: Equatable>(_ arr: [T], _ target: T) -> Int? {
for (index, item) in arr.enumerated() {
if item == target {
return index
}
}
return nil
}
// Usage:
let numbers = [64, 25, 12, 22, 11]
if let index = linearSearch(numbers, 22) {
print("Number found at index \(index).")
} else {
}
``````

### Output:

```Number found at index 3.
```

### Explanation:

1. The linearSearch function is a generic function which means it can work with any datatype that conforms to the Equatable protocol.

2. The function iterates over each element in the dataset using a for loop.

3. Inside the loop, the current item is compared to the target value.

4. If they match, the function returns the index of the current item.

5. If the loop completes without finding the target, nil is returned, indicating the target is not in the dataset.

6. The complexity of the linear search is O(n), where n is the number of items in the dataset. It's not the most efficient search method for large datasets, but it's straightforward and easy to understand.