使用排序对数组进行升序和降序排序

Question

我想按第三个和第一个元素对元组数组进行排序，因此我使用了以下代码：

import scala.util.Sorting
val pairs = Array(("a", 5, 2), ("c", 3, 1), ("b", 1, 3))

// sort by the 3rd element, then 1st
Sorting.quickSort(pairs)(Ordering[(Int, String)].on(x => (x._3, x._1)))

我的问题是，在前面的例子中，我可以按第三个元素和第一个元素的升序排序，也可以按它们的降序排序（使用反向）。但是如何按第三个元素的升序和第一个元素的降序排序。

请在你的回答中考虑以下情况：

Array[Array[People]]  

在这种情况下，我不知道内部数组的确切大小（取决于我读入该数组的文件模式），我想按侧中的所有项进行排序（一些升序和一些降序）。

编辑：看起来，我明白了。

这是我的完整案例：我有以下课程：

  sealed trait GValue extends Serializable with Ordered[GValue]{
def compare(o: GValue): Int = {
  o match {
    case GDouble(v) => this.asInstanceOf[GDouble].v compare v
    case GString(v) => this.asInstanceOf[GString].v compare v
  }
}

case class GDouble(v: Double) extends GValue

case class GString(v: String) extends GValue

我想做一个这样的代码。

// (startInterval, StopInterval, ArrayOfColumns)
    val intervals: Array[(Long,Long,Array[GValue])] =
Array((10,20,Array(GDouble(10.2), GString("alarm"), GString("error"),GDouble("100.234"))),
    (30,2000,Array(GDouble(-10.2), GString("alarm"), GString("warn"),GDouble("0.234"))))

模式或内部数组将根据输入文件进行更改（在示例中，它是Double、String、String、Double，但可能是Double、Double或其他内容）。我想找到一种方法来分类，覆盖内部数组的所有情况（关于类型和长度），升序和降序。

我目前所做的是将内部数组更改为Iterable，然后使用Ordering[Iterable[GValue]]对[Iterable[GValue]]进行排序或排序。颠倒但我想按不同的方向排序（第一列升序，第二列降序，第三列升序，依此类推）

Answer 1

对于要排序Strings desceding的示例，请在排序之前添加此项

  implicit object ReverseStringOrdering extends Ordering[String] {
    def compare(x: String, y: String) = -1 * x.compareTo(y)
  }

所以，一般来说，只需添加隐式排序对象，该对象的类型是要使用重写的比较方法进行降序排序的。此解决方案仅在按不同类型排序时有效。

如果要按第一项升序和第二项降序排序，请在排序前添加以下内容：

 implicit def AscFirstDescSecondTuple2[T1, T2](implicit ord1: Ordering[T1], ord2: Ordering[T2]): Ordering[(T1, T2)] =
    new Ordering[(T1, T2)]{
      def compare(x: (T1, T2), y: (T1, T2)): Int = {
        val compare1 = ord1.compare(x._1, y._1)
        if (compare1 != 0) return compare1
        val compare2 = -1 * ord2.compare(x._2, y._2)
        if (compare2 != 0) return compare2
        0
      }
    } 

Answer 2

使用来自另一个问题的Régis Jean Gilles的组合订单，我们可以组合多个订单。

// Ordering to sort an Array[GValue] by column "col"
def orderByColumn(col: Int) = Ordering.by { ar: Array[GValue] => ar(col - 1) }

val `By Col3-Desc/Col1` = 
  CompositeOrdering(orderByColumn(3).reverse, orderByColumn(1))

val `By Col1/Col2/Col3` = 
  CompositeOrdering(orderByColumn(1), orderByColumn(2), orderByColumn(3))

现在，我们可以排序类型Array[GValue]的数组，并且可以使用sortBy排序间隔：

intervals.sortBy(_._3)(`By Col3-Desc/Col1`)

如果要使用排序对间隔数组进行排序。快速排序，我们需要对元组进行排序：

type Interval = (Long, Long, Array[GValue])
implicit object tupleByArray extends Ordering[Interval] {
  def compare(a: Interval, b: Interval) = a._3 compare b._3
}

现在，您可以使用排序对间隔进行排序。快速排序：

implicit val arrOrd = `By Col3-Desc/Col1`
Sorting.quickSort(intervals)

// Array[(Long, Long, Array[GValue])] = 
// Array(
//  (30,2000,Array(GDouble(-10.2), GString(alarm), GString(warn),  GDouble(0.234))), 
//  (10,20,Array(GDouble(10.2), GString(alarm), GString(error), GDouble(100.234)))
// )

我在问题更新之前留下了我的答案：

Eric Loots有一篇关于多字段排序的伟大文章。

在Array[People]的情况下，这可能看起来像：

case class People(name: String, age: Int)

object PeopleOrdering {
  // sort by name descending and age ascending
  implicit object `By Name-Rev/Age` extends Ordering[People] {
    def compare(a: People, b: People): Int = {
      import scala.math.Ordered._
      implicit val ord = Ordering.Tuple2[String, Int]
      (b.name, a.age) compare (a.name, b.age)
    }
  }
}

val people = Array(People("Alice", 40), People("Bob", 50), People("Charlie", 20))
Sorting.quickSort(people)(PeopleOrdering.`By Name-Rev/Age`)
// > people
// Array[People] = Array(People(Bob,20), People(Bob,50), People(Alice,40))

val array = Array(people, Array(People("B", 1), People("C", 2)))
array.foreach(ps => Sorting.quickSort(ps)(PeopleOrdering.`By Name-Rev/Age`))
// > array
// Array[Array[People]] = Array(
//   Array(People(Bob,20), People(Bob,50), People(Alice,40)), 
//   Array(People(C,2), People(B,1))
// )