Bubble sorting an array in Swift, compiler error on swap

Question

I wrote a really simple bubble sort for a card game. It takes an array of "Card" objects, each of which has a an "order" attribute which indicates the value to be sorted against for the game in question.

The following code stopped compiling some time between Swift Beta 1 and Beta 6, and I'm not exactly sure why.

 ///Sort the cards array by order
  func sortCards(cards: Array<Card>) -> Array<Card> {
    var sorted = false
    while sorted == false {
      sorted = true
      for i in 0...cards.count - 2 {
        if cards[i].order > cards[i+1].order {
          sorted = false
          var first = cards[i]
          var second = cards[i + 1]
          cards[i] = second    //ERROR
          cards[i + 1] = first //ERROR
        }
      }
    }
    return cards
  }

The lines where the swap occurs bombs out with a very cryptic message:

@!value $T5 is not identical to 'Card'

What changed, and what am I doing wrong here?

Bonus question: How am I supposed to understand the error message?

I know almost nothing about swift, so I'll delete this question if it's wrong. Is it possible your Array is some sort of readonly and won't allow any assignments? Just basing that off of this — JKillian
– JKillian, Commented Aug 26, 2014 at 17:06
possible duplicate of Swift function that takes in array giving error: '@lvalue $T24' is not identical to 'CGFloat' — Antonio
– Antonio, Commented Aug 26, 2014 at 17:11
@jtbandes I am unfamiliar with that syntax. What would that mean? — Mikey T.K.
– Mikey T.K., Commented Aug 26, 2014 at 17:38

Golden Thumb · Accepted Answer · 2017-04-08 17:06:58Z

I played with the following using swift 3. Hope it'll help some people who come here.

bubble sort:

func bubble(arr: inout [Int]) {
    for i in (1..<arr.count).reversed() {
        for j in 0..<i where arr[j] > arr[j + 1] {
            swap(&arr[j], &arr[j + 1])
        }
    }
}

using stride:

func bubbleStride(arr: inout [Int]) {
    for i in stride(from: arr.count - 1, to: 1, by: -1) {
        for j in 0..<i where arr[j] > arr[j + 1] {
            swap(&arr[j], &arr[j + 1])
        }
    }
}

using while:

func bubbleWhile(arr: inout [Int]) {
    var i = arr.count - 1
    while(i > 0) {
        var j = 0
        while(j < i) {
            if arr[j] > arr[j + 1] {
                swap(&arr[j], &arr[j + 1])
            }
            j += 1
        }
        i -= 1
    }
}

This can be used to generate a random array of integers:

import Cocoa

func ints(cnt: Int, ceiling: Int) -> [Int] {
    let arr = Array(repeating: 0, count: cnt)
    return arr.map { _ in Int(arc4random_uniform(UInt32(ceiling))) }
}

E.g.:

let a = ints(cnt: 10, ceiling: 100)
print(a)

var b = a
bubble(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]

Martin R · Accepted Answer · 2014-08-26 17:19:46Z

3

Function parameters are by default constant (as if declared with let). If you want to modify the parameter inside your function, you have to declare it as a variable:

func sortCards(var cards: Array<Card>) -> Array<Card> { ...

Note that only the local parameter cards is modified, not the array passed as an argument to the function (which seems to be your intention because the function returns a new array).

edited Aug 26, 2014 at 17:19

answered Aug 26, 2014 at 17:10

Martin R

541k98 gold badges1.3k silver badges1.4k bronze badges

Comments

David Berry · Accepted Answer · 2014-08-26 19:08:28Z

2

If you declare the function like this, then the array is inmutable. You need to use the keyword inoutlike this:

func sortCards(inout cards: Array<Card>) -> Array<Card> {
//code
}

Then you call it with &:

sortCards(&myArray)

Explanation

The whole model of Arrays and pass by value/reference has changed during the beta process.

In beta 1 arrays passed into subroutines were only kind of passed by value. Arrays passed by value (and let arrays) were still modifiable as long as you didn't change the length of the array, thus breaking the pass-by-value rules and allowing your original code to work.

In beta 4 I believe it was, they changed arrays to effectively always be passed by value and changed constant arrays (let) do be truly unmodifiable, which resulted in your code not working and breaking in the compile phase.

The inout keyword changes the array to be passed by reference instead of by value and changes it from being implicitly defined with let to defined with var, which means the array is now mutable, and changes to the array are seen by the caller.

edited Aug 26, 2014 at 19:08

David Berry

41.3k12 gold badges87 silver badges96 bronze badges

answered Aug 26, 2014 at 17:07

Zalykr

1,5241 gold badge10 silver badges21 bronze badges

1 Comment

Mikey T.K. Over a year ago

I wish I could accept both of these because they're both completely relevant. They must have tightened up the syntax checking because this code definitely worked on beta 1. Thanks!

OOMMEN · Accepted Answer · 2017-12-12 12:04:29Z

0

Here is bubble sort implemented in swift 4.0.2

var array = [15,11,20,14,12,13,17,16,18,19]
var sortedArray = Array(array)
var sortedAboveIndex = array.count 

for i in 0 ..< sortedAboveIndex-1 {

  for j in 0 ..< sortedAboveIndex-i-1 {

      if (sortedArray[j] > sortedArray[j+1]) {

          sortedArray.swapAt(j, j+1)        
      }
  }

}

print(sortedArray)

if any queries on above code please comment below

answered Dec 12, 2017 at 12:04

OOMMEN

2593 silver badges6 bronze badges

Comments

Hadži Lazar Pešić · Accepted Answer · 2019-01-03 23:02:51Z

0

The function always runs O(n^2) time even if the array is sorted. It can be optimized by stopping the algorithm if inner loop didn’t cause any swap.

func main() {
    var array: [Int] = [1, 3, 15, 6, 8, 12, 10, 33, 2, 88]
    var swapped = false

    for i in 0..<array.count {
        for j in 0..<array.count - i - 1 {
            if array[j] > array[j + 1] {
//                let temp = array[j]
//                array[j] = array[j+1]
//                array[j+1] = temp
                array.swapAt(j, j + 1)
                swapped = true
            }
        }

        if swapped == false {
            break
        }
    }

    print(array)
}

answered Jan 3, 2019 at 23:02

Hadži Lazar Pešić

1,0611 gold badge13 silver badges21 bronze badges

Comments

Yano · Accepted Answer · 2020-04-17 06:57:02Z

Swift 5: Generic bubble sort method,

func bubbleSort<T: Comparable>(with array: inout [T]) -> [T] {
    for i in 1..<array.count {
        for j in 0..<array.count-i where array[j] > array[j+1] {
            array.swapAt(j, j+1)
        }
    }
    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(bubbleSort(with: &intArray))
print(bubbleSort(with: &floatArray))
print(bubbleSort(with: &doubleArray))
print(bubbleSort(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"]

Mr.Javed Multani · Accepted Answer · 2021-05-23 11:07:11Z

0

100% working tested code

func bubbleSort(arrValue:[Int])->[Int]{
       var arr = arrValue
       for i in 0..<arr.count-1{
           for j in 0..<arr.count-i-1{
               if arr[j] > arr[j+1]{
                   arr.swapAt(j, j+1)
               }
           }
       }
       print(arr)
       return arr
   }

answered May 23, 2021 at 11:07

Mr.Javed Multani

13.5k5 gold badges56 silver badges55 bronze badges

Comments

Paul B · Accepted Answer · 2022-05-25 13:44:02Z

0

Here is a way to sort in place anything Comparable.

extension Array where Element: Comparable {
    mutating func bubble(by areInIncrreasingOrder: (Element, Element) -> Bool) {
        for i in (0 ..< count) {
            for j in (0 ..< count - i - 1) where !areInIncrreasingOrder(self[j], self[j + 1]) {
                swapAt(j, j + 1)
            }
        }
    }
}

Quick check:

var arr = (0...8).map{ _ in Int.random(in: 0...100)}
arr
arr.bubble(by: <)
arr.sorted(by: <)

answered May 25, 2022 at 13:44

Paul B

5,33347 silver badges57 bronze badges

Collectives™ on Stack Overflow

Bubble sorting an array in Swift, compiler error on swap

8 Answers 8

Comments

Comments

1 Comment

Comments

Comments

Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

8 Answers 8

Comments

Comments

1 Comment

Comments

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related