如何检查给定列表[Int]是否在scala中排序？

我想知道scala中是否存在

isSorted（）

函数

问题：检查

List[Int]

是否已排序，如果未排序，请删除最小的数字并重新排序，直到

List[Int]

已排序为止

---

我只需要一行或两行程序。

这不是最好的解决方案，但您可以使用列表上的排序方法，然后将其与原始方法进行比较

def sorted(l: List[Int]): Boolean = l == l.sorted

---

您可以比较输入序列中的每一对，以查找包含多个项目的列表：

def isSorted[T](s: Seq[T])(implicit ord: Ordering[T]): Boolean = s match {
    case Seq() => true
    case Seq(_) => true
    case _ => s.sliding(2).forall { case Seq(x, y) => ord.lteq(x, y) }
}

---

这是你的一行作业解决方案

def removeMinWhileNotSorted[A: Ordering](xs: List[A]): List[A] =  if (xs == xs.sorted) xs else xs.splitAt(xs.indexOf(xs.min))  match {case (prefix, m :: postfix) => removeMinWhileNotSorted(prefix ++ postfix)}

有点懒：

def isSorted(l:List[Int]):Boolean = {
   val list = l.view
   !list.zip(list.tail).exists {case (x,y) => x>y}
}

---

一个低效但容易理解的答案：

def specialSort(a: List[Int]): List[Int] = 
  if (a == a.sorted) a 
  else specialSort(a.filterNot(_ == a.min))

---

它不存在。但这很容易做到：创建一个列表，其中包含列表的关联版本，并按需要排序相同的列表，并验证关联列表的两个元素是否相同

大概是这样的：

import org.junit.Assert._

val sortedList = List(1, 3, 5, 7)
val unsortedList = List(10, 1, 8, 3, 5, 5, 2, 9)

// detailed test. It passes.
sortedList
  .zip(sortedList.sortWith((a,b) => a.compareTo(b) < 0)) // this is the required sorting criteria.
  .foreach(x => assertEquals("collection is not sorted", x._1, x._2))

// easier to read but similar test. It fails.
unsortedList
  .zip(unsortedList.sorted) // this is the required sorting criteria.
  .foreach(x => assertEquals("collection is not sorted", x._1, x._2))

import org.junit.Assert_
val sortedList=列表（1,3,5,7）
val unsortedList=List（10,1,8,3,5,5,2,9）
//详细测试。它过去了。
分类表
.zip（sortedList.sortWith（（a，b）=>a.compareTo（b）<0））//这是所需的排序标准。
.foreach（x=>assertEquals（“集合未排序”，x._1，x._2））
//更容易阅读，但类似的测试。它失败了。
未分类列表
.zip（unsortedList.sorted）//这是必需的排序条件。
.foreach（x=>assertEquals（“集合未排序”，x._1，x._2））

功能可以是：

def isSorted(list: List[Int]): Boolean = !list.zip(list.sortWith((a, b) => a.compareTo(b) < 0)).exists(p => !p._1.equals(p._2))

def被排序（list:list[Int]）：布尔=！list.zip（list.sortWith（（a，b）=>a.compareTo（b）<0））存在（p=>！p._1.等于（p._2））

执行排序只是为了检查列表是否已排序，这有点过分了。这里的最佳解决方案似乎是最明显的，它只是用人类语言描述问题并将其转换为代码：

def isSorted[T](list: List[T])(implicit ord: Ordering[T]): Boolean = list match {
    case Nil => true // an empty list is sorted
    case x :: Nil => true // a single-element list is sorted
    case x :: xs => ord.lteq(x, xs.head) && isSorted(xs) // if the first two elements are ordered and the rest are sorted, the full list is sorted too
}

如果您希望它更短，您可以用第二个案例换取一点可读性：

def isSorted[T](list: List[T])(implicit ord: Ordering[T]): Boolean = list match {
    case Nil => true
    case x :: xs => xs.headOption.fold(true)(ord.lteq(x, _)) && isSorted(xs)
}

如果您想要一行程序，则根本不可读：

def isSorted[T](list: List[T])(implicit ord: Ordering[T]): Boolean = list.headOption.fold(true)(a => list.tail.headOption.fold(true)(ord.lteq(a, _) && isSorted(list.tail.tail)))

def排序[T（p.size==1）| p（0）
l==l.sorted
对我不起作用，我设法用
l sameElements l.sorted
我认为如果两个相邻元素相等，这也是合法的

 def isSorted[T <% Ordered[T]](l: List[T]):Boolean ={
   val a = l.toArray
   (1 until a.length).forall(i => a(i-1) <= a(i))
 }

def isSorted[ta（i-1）另一种可能性（不一定比其他一些建议更好）

def isSorted（xs:List[Int]）：Boolean=（xs.tail-zip-xs）.forall（pair=>pair.\u 1-pair.\u 2>0）
您可以使用尾部递归来减少创建对象的次数，并避免长列表的堆栈溢出。此版本是惰性的，函数在第一个无序对之后立即返回值

@scala.annotation.tailrec
def isSorted[T:排序]（值：列表[T]）：布尔={
导入scala.math.Ordering.Implicits_
值匹配{
案例fst：：snd:：u如果fst被排序（values.tail）
大小写：：：=>false
大小写=>true
}
}
写
x
而不是
ord。lt
会更清楚：）并且
应该是ord.lteq（x，y），请编辑您的答案。我无法提交编辑，因为它少于6个字符。如果第二个参数指定是否使用
ord.lteq
或
ord.gteq
或其他方法来实际回答问题的两个位，我可以编写一个双参数版本。警告：匹配可能并不详尽。它将在以下输入上失败：（z，Nil）@实际上它将包含一个保证元素（最小值）.所以你可以忽略警告为什么在一行中写这么多代码而没有任何解释？是的，为什么在一行中写这么多代码而没有任何解释？你应该提供一个解释为什么以及你的代码如何解决这个问题，这将大大提高质量。一个有两组括号的函数？！wtf？回答不错。智慧h这个老问题（超过3年）和这么多现有答案（11），通常最好包含解释您的答案与其他答案不同的文本。在这种情况下，您的答案看起来与尼亚夫罗的答案非常相似，只是您选择了减法并比较
对。_1-对。_2>0
而不是直接比较
对。_1>对。_2
。
 def isSorted[T <% Ordered[T]](l: List[T]):Boolean ={
   val a = l.toArray
   (1 until a.length).forall(i => a(i-1) <= a(i))
 }

def isSorted[T <% Ordered[T]](a: List[T]): Boolean =
    if (a == Nil) true // an empty list is sorted
    else a.foldLeft((true, a.head))(
        (prev, v1) => {
            val (p, v0) = prev
        (p && v0 <= v1, v1)
    })._1

isSorted(Nil) -> true 
isSorted(1 :: Nil) -> true
isSorted(2 :: 3 :: Nil) -> true
isSorted(1 :: 2 :: 5 :: 8 :: Nil) -> true
isSorted(1 :: 1 :: 2 :: 2 :: Nil) -> true
isSorted(3 :: 2 :: Nil) -> false
isSorted(1 :: 2 :: 3 :: 1 :: Nil) -> false