Swift modify Int array for InsertionSort algorithm - arrays

Question

I'm very new to Swift and I wanted to know how I'm supposed to modify an Int contained in my Int[]? I made it like I'd do it in Java but it, obviously, doesn't work: I get a Cannot assign to immutable value of type 'Int' compilation error.
Here is my code:
import Foundation
func createRandomArray(length: Int) -> [Int]{
var random = [Int]()
for index in 0...length{
random.append(Int(arc4random_uniform(100)))
}
return random
}
func insertionSort(toSort: [Int]) -> [Int]{
var length = toSort.count
for index in 1...length-1{
var key = toSort[index]
var previous = index-1
while(previous>0 && toSort[previous]>key){
// ERROR IS THERE
toSort[previous+1] = toSort[previous]
previous--
}
}
return toSort
}
var array = createRandomArray(10)
print(array)
print(insertionSort(array))
I thought that using a var instead of let will give a mutable object so that's why I'm a bit lost.
Thanks for help
EDIT:
I got this working answer yet, thanks to #vacawama:
import Foundation
func createRandomArray(length: Int) -> [Int]{
var random = [Int]()
for index in 0...length{
random.append(Int(arc4random_uniform(100)))
}
return random
}
func insertionSort(var toSort: [Int]) -> [Int]{
for firstIterator in 1...toSort.count-1{
var currentValue = toSort[firstIterator]
var previousPosition = firstIterator-1
while(previousPosition>=0 && toSort[previousPosition]>currentValue){
swap(&toSort[previousPosition+1], &toSort[previousPosition])
previousPosition--
}
}
return toSort
}
var array = createRandomArray(10)
print(array)
print(insertionSort(array))

Answer 1

Updated Answer for Swift 5.x and Beyond
Swift has had many changes in the 7 years since I answered this question. It is no longer valid to insert var into the function header to make an array modifiable. The modern way to do that is to make var toSort = toSort the first line of the function body.
Here is a modification of the OP's code with modern Swift updates:
func createRandomArray(_ length: Int) -> [Int] {
var random = [Int]()
for _ in 0..<length {
random.append(Int.random(in: 0..<100))
}
return random
}
func insertionSort(_ toSort: [Int]) -> [Int] {
var toSort = toSort
for firstIterator in 1..<toSort.count {
let currentValue = toSort[firstIterator]
var previousPosition = firstIterator - 1
while (previousPosition >= 0 && toSort[previousPosition] > currentValue) {
toSort.swapAt(previousPosition + 1, previousPosition)
previousPosition -= 1
}
}
return toSort
}
var array = createRandomArray(10)
print(array)
print(insertionSort(array))
A shorter version of createRandomArray:
func createRandomArray(_ length: Int) -> [Int] {
(0..<length).map { _ in .random(in: 0..<100) }
}
Note: Your insertionSort() will crash if it is passed an empty array. Add this guard statement to the start of the function body to prevent that:
guard !toSort.isEmpty else { return toSort }
Original Answer (now obsolete) for Swift 1.0
By default, array parameters are immutable within the called function. If you want to modify the copy of the array that is passed to insertionSort, add var before toSort in the function header.
func insertionSort(var toSort: [Int]) -> [Int]{

Answer 2

I played with the following using swift 3. Hope it'll help some people who come here.
import Cocoa
func ints(cnt: Int, ceiling: Int) -> [Int] {
var arr = [Int]()
for _ in 0 ..< cnt {
arr.append(Int(arc4random_uniform(UInt32(ceiling))))
}
return arr
}
func insertion(arr: inout [Int]) {
for i in 1..<arr.count {
var j = i
let x = arr[i]
while j > 0 && arr[j - 1] > x {
arr[j] = arr[j - 1]
j -= 1
}
arr[j] = x
}
}
let a = ints(cnt: 10, ceiling: 100)
print(a)
var b = a
insertion(arr: &b)
print(b)
output:
[13, 30, 68, 19, 1, 4, 28, 65, 96, 13]
[1, 4, 13, 13, 19, 28, 30, 65, 68, 96]
For comparison, here is an implementaion in java:
void insertionSort(int[] arr) {
for(int i = 1; i < arr.length; i++) {
int x = arr[i];
int j = i;
while(j > 0 && arr[j - 1] > x) {
arr[j] = arr[j - 1];
j--;
}
arr[j] = x;
}
}

Answer 3

struct InsertionSort {
static func sort(data: Array<Int> = [5,9,1,8,2,4,3,1]) {
var data = data
for (i, e) in data.enumerated() where i > 0 && e < data[i - 1] {
traverseBackwardAndSwap(i, &data)
}
printData(data)
}
private static func traverseBackwardAndSwap(_ i: Int, _ data: inout [Int]) {
for i in (0...i).reversed() where i > 0 && data[i] < data[i-1] {
let temp = data[i]
data[i] = data[i-1]
data[i-1] = temp
}
}
private static func printData(_ data: [Int]) {
for e in data {
print("\(e)")
}
}
}

Answer 4

Swift 5: Generic Insertion sort
func insertionSort<U: Comparable>(with array: inout [U]) -> [U] {
for i in 1..<array.count {
let temp = array[i]
var insertionIndex = i
for j in (0...i).reversed() where j>0 && temp < array[j-1] {
array[j] = array[j-1]
insertionIndex = j-1
}
array[insertionIndex] = temp
}
return array
}
Input:-
var intArray = [8, 3, 5, 10, 4, -1, 17, 3, 18, 10]
var floatArray = [12.231, 12.23, 14.5, 3.4, 67.899, 0.0, -1.234]
var doubleArray = [123.43555, 123.1223332, -121.2212, 23.343434, 1.232434]
var stringArray = ["Ratheesh", "Srini", "Thangu", "Muthu", "Gopi"]
print(insertionSort(with: &intArray))
print(insertionSort(with: &floatArray))
print(insertionSort(with: &doubleArray))
print(insertionSort(with: &stringArray))
Output:-
[-1, 3, 3, 4, 5, 8, 10, 10, 17, 18]
[-1.234, 0.0, 3.4, 12.23, 12.231, 14.5, 67.899]
[-121.2212, 1.232434, 23.343434, 123.1223332, 123.43555]
["Gopi", "Muthu", "Ratheesh", "Srini", "Thangu"]