检查列表是否按升序或降序排序或未按haskell排序？

Question

我是 Haskell 的新手。我刚刚学习了两周的 Haskell。我真的不明白 if else 语句和 haskell 的列表理解是如何工作的。所以我想做一个函数，可以找出排序类型，例如列表是按升序或降序排序或根本不排序的。我知道如何检查列表是否按升序和降序排序，但我不知道如何检查列表是否根本没有排序。

data SortType = Ascending | Descending | NotSorted deriving (Show)

sorted :: (Ord a) => [a] -> TypeOfSort 
sorted [] = Ascending
sorted [x] = Ascending
sorted (x:y:xs) | x < y = sorted (y:xs) 
            | otherwise = Descending
sorted_  = Ascending

如果有人能告诉我该怎么做，那将是一个很大的帮助。谢谢你。 P/s：这不是作业/工作的东西，而是我想学习的东西。

Answer 1

你的函数有问题的部分是| otherwise = Descending。根据您的函数定义，如果列表中有两个连续的示例，例如x >= y，则该函数为降序。这不是True：如果 all 两个连续的元素 x > y（或 x >= y，如果您不要求它严格降序，则函数正在下降） .

此外，这里还有一个问题是一个包含一个元素（或没有元素）的列表可以被视为Ascending 和Descending。所以我认为我们要做的第一件事就是定义一些语义。我们可以决定使输出成为TypeOfSort 项目的列表，或者我们可以决定扩展TypeOfSort 的选项数量。

在这个答案中，我将选择最后一个选项。我们可以将TypeOfSort 扩展为：

data TypeOfSort = Ascending | Descending | Both | NotSorted
    deriving (Show)

现在我们可以处理函数本身了。这里的基本情况当然是空列表[] 和一个元素列表[_]：

sorted [] = Both
sorted [_] = Both

现在我们需要定义归纳案例。列表何时升序排序？如果所有元素（严格）大于前一个元素。类似地，如果所有元素（严格）小于前一个元素，则列表按降序排序。现在让我们假设严格性。以后修改函数定义很容易。

因此，如果我们有一个包含两个或多个元素的列表，如果以第二个元素开头的列表是 Ascending 或 Both 和 x < y，则列表是 Ascending，或者换句话说：

sorted (x:y:xs) | Both <- sort_yxs, x < y = Ascending
                | Ascending <- sort_yxs, x < y = Ascending
    where sort_yxs = sorted (y:xs)

降序也是如此：如果列表的其余部分按降序排列，并且第一个元素大于第二个元素，则列表按降序排列：

                | Both <- sort_yxs, x > y = Descending
                | Ascending <- sort_yxs, > y = Descending
    where sort_yxs = sorted (y:xs)

在所有剩余的情况下，这意味着列表的某些部分是Ascending，某些部分是Descending，因此列表是NotSorted。

                | otherwise = NotSorted

或将这些放在一起：

sorted [] = Both
sorted [_] = Both
sorted (x:y:xs) | Both <- sort_yxs, x < y = Ascending
                | Ascending <- sort_yxs, x < y = Ascending
                | Both <- sort_yxs, x > y = Descending
                | Ascending <- sort_yxs, x > y = Descending
                | otherwise = NotSorted
    where sort_yxs = sorted (y:xs)

重构：使TypeOfSort 成为Monoid

上面的定义包含很多边缘情况，这使得编写一个简单的程序变得很困难。我们可以通过引入一些实用函数来简化它。例如，这可以通过定义一个接受两个TypeOfSorts 然后返回交集的函数来完成。这样的函数可能如下所示：

intersect Both x = x
intersect x Both = x
intersect Ascending Ascending = Ascending
intersect Descending Descending = Descending
intersect _ _ = NotSorted

这实际上形成了一个以Both 为标识元素的monoid：

instance Monoid where
    mappend Both x = x
    mappend x Both = x
    mappend Ascending Ascending = Ascending
    mappend Descending Descending = Descending
    mappend _ _ = NotSorted

    mempty = Both

现在我们可以将定义改写为：

sorted [] = Both
sorted [_] = Both
sorted (x:y:ys) | x > y = mappend rec Ascending
                | x < y = mappend rec Descending
                | otherwise = NotSorted
    where rec = sorted (y:ys)

Answer 2

我的解决方案不使用排序功能且不使用递归：

data SortType = Ascending | Descending | NotSorted | Flat | Unknown deriving (Show)

sorted :: (Ord a) => [a] -> SortType 
sorted [] = Unknown
sorted [a] = Flat
sorted xs  
    | and [x == y | (x, y) <- zipPairs xs] = Flat
    | and [x <= y | (x, y) <- zipPairs xs] = Ascending
    | and [x >= y | (x, y) <- zipPairs xs] = Descending
    | otherwise                            = NotSorted

zipPairs :: [a] -> [(a, a)]
zipPairs xs = zip xs (tail xs)

使用 lambdas 可能更快

all (\(x, y) -> x <= y) (zipPairs xs)

在 Python 中我可能会做这样的事情

from itertools import izip, islice

n = len(lst)

all(x <= y for x, y in izip(islice(lst, 0, n - 1), islice(lst, 1, n)))

Answer 3

我猜你也可以这样做；

data Sorting = Why | Karma | Flat | Descent | Ascent deriving (Show)

howSorted :: Ord a => [a] -> Sorting
howSorted xs | xs == []                    = Why
             | all (== head xs) $ tail xs  = Flat
             | and $ map (uncurry (<=)) ts = Ascent
             | and $ map (uncurry (>=)) ts = Descent
             | otherwise                   = Karma
             where ts = zip xs $ tail xs

Answer 4

我们已经从 Data.List 中实现了sort，我们可以使用它来实现这一点。

import Data.List (sort)

sorted xs 
    | sort xs == xs = Ascending
    | reverse (sort xs) == xs = Descending
    | otherwise = NotSorted

如果排序后的列表等于列表，则必须使用升序排序。

如果排序后的列表，反转后，等于列表，那么它必须使用降序排序。

否则不排序。

正如@Benjamin-Hodgson 指出的那样，边缘条件可能需要考虑。使用此实现，空列表计为已排序，一个项目的列表也是如此，同一项目的重复列表也是如此。

用法：

λ> sorted [1..5]
Ascending
λ> sorted [5,4..1]
Descending
λ> sorted [1,3,1]
NotSorted
λ> sorted []
Ascending
λ> sorted [1]
Ascending
λ> sorted [1,1,1]
Ascending

或者，我们可以使用sortBy 来反转情况，以避免必须完全反转列表。这只是按默认比较函数排序，参数翻转，因此小于变为大于。

import Data.List (sort, sortBy)

sorted xs 
    | sort xs == xs = Ascending
    | sortBy (flip compare) xs == xs = Descending
    | otherwise = NotSorted