泛型冒泡排序实现是否正确？如何解决编译错误？

核心问题解释 #

1. 泛型类型无比较能力：代码中泛型T没有任何约束，Scala无法确定所有T类型都支持>比较操作，这是编译错误的直接原因。
2. 变量作用域冲突：外层while循环的var count和内层for循环的count重名，内层变量会覆盖外层，导致外层循环逻辑彻底失效。
3. 排序逻辑冗余：标准冒泡排序可以通过记录是否发生交换来提前终止循环，避免不必要的遍历。

修正与优化后的实现 #

方式一：使用Ordered上下文边界（适用于本身支持比较的类型） #

def sortAny[T <: Ordered[T]](list: Array[T]): Array[T] = {
  var swapped = true
  var n = list.length
  while (swapped) {
    swapped = false
    for (i <- 0 until n - 1) {
      if (list(i) > list(i + 1)) {
        val temp = list(i)
        list(i) = list(i + 1)
        list(i + 1) = temp
        swapped = true
      }
    }
    n -= 1 // 每轮排序后，最后一个元素已就位，无需再比较
  }
  list
}

方式二：使用Ordering隐式参数（更灵活，支持自定义排序规则） #

这种方式不需要类型本身实现Ordered，可以通过隐式Ordering实例来定义比较逻辑，适用性更广。

def sortAny[T](list: Array[T])(implicit ord: Ordering[T]): Array[T] = {
  import ord._ // 导入Ordering的比较操作符
  var swapped = true
  var n = list.length
  while (swapped) {
    swapped = false
    for (i <- 0 until n - 1) {
      if (list(i) > list(i + 1)) {
        val temp = list(i)
        list(i) = list(i + 1)
        list(i + 1) = temp
        swapped = true
      }
    }
    n -= 1
  }
  list
}

额外说明 #

• 两种实现都修复了变量重名问题，将内层循环变量改为i，避免覆盖外层的循环控制变量。
• 加入了swapped标记，当某一轮遍历没有发生任何交换时，说明数组已经有序，直接终止循环，提升排序效率。
• 方式二支持自定义排序，比如对自定义类排序时，可以提供自定义的Ordering实例：

  case class Person(name: String, age: Int)
  implicit val personOrdering: Ordering[Person] = Ordering.by(_.age)
  val people = Array(Person("Alice", 30), Person("Bob", 25))
  sortAny(people) // 按年龄升序排序
  

内容的提问来源于stack exchange，提问作者tokyo