在几乎排序的数组中检测未排序的元素

Question

我有一组已排序的样本，但由于数据中的错误，有时未排序的值会蔓延。我需要检测这些值并删除它们。我将在下面展示一些示例数据集。

20 30 21 22 23 24 25

30 31 21 22 23 24 25

30 21 22 23 24 25 26

20 21 22 23 18 25 26

20 15 21 22 23 24 25

在每种情况下，粗斜体数字都是应该删除的。删除这些数字/检测这些数字的索引的算法是什么？

Answer 1

检测相对简单，步骤更少 - 您可以在O(n) 时间内完成。只需遍历数组并将每个元素与下一个元素进行比较。您将能够找到（并标记索引或丢弃）乱序数字。

但是，您的第二种情况使这样做成为一个问题。我会假设您总是希望保留数字列表中最长的递增子序列（如第二种情况）。

您可以使用数组和二分搜索有效地解决这个问题。该算法对每个序列元素进行一次二分查找，其总时间可以表示为O(n log n)。

按顺序处理序列元素，保持目前找到的最长递增子序列。将序列值表示为X[0], X[1]等。L表示迄今为止发现的最长递增子序列的长度。

M[j] 存储最小值X[k] 的索引k，这样在k ≤ i 范围内有一个长度增加的子序列j 以X[k] 结尾。 j ≤ k ≤ i 总是。 P[k]存储了X[k]的前身的索引在以X[k]结尾的最长递增子序列中

序列X[M[1]], X[M[2]], ..., X[M[L]] 在算法的所有点上总是不递减的。

P = array of length N
M = array of length N + 1 // Using a 1 indexed array for ease of understanding

L = 0
for i in range 0 to N-1:
   // Binary search
   lo = 1
   hi = L
   while lo ≤ hi:
       mid = ceil((lo+hi)/2)
       if X[M[mid]] < X[i]:
           lo = mid+1
       else:
           hi = mid-1

newL = lo

P[i] = M[newL-1]
M[newL] = i

if newL > L:
    L = newL

S = array of length L
k = M[L]
for i in range L-1 to 0:
    S[i] = X[k]
    k = P[k]

return S

这个伪代码可以在Wikipedia article上找到。

如果您确实希望将乱序元素保留在列表中，只需使用插入排序对数组进行排序。

Answer 2

仅检测

检查（检查每个元素和下一个元素）至少需要 N-1 个步骤。

但它是模棱两可的：在清单 2 中，有什么问题？ 30/31，还是 21/.../25 ？

如果坏号码是孤立的，您只需将其删除。但是，如果您有 2 个数字，该怎么办？您必须定义更多规则。

检测和排序：

复杂性：

如果您的列表完美排序，则需要 N-1 步（检查每个元素和下一个元素）。

如果有 一个 未排序的元素，则需要 log N 才能在合适的位置替换它（如果我认为其他所有内容都已排序，并且在像二叉树这样的特殊结构中）。

如果有 k 个未排序的元素，则需要 k log N。

所以 N（检查）+ k log N（插入）。

如果一切都乱了套，N log N，这是排序的经典复杂度。

算法：

因此，最简单的算法是在平衡树中迭代并插入到合适的位置。它是按插入排序的。

就像smoothsort：https://en.wikipedia.org/wiki/Smoothsort

Answer 3

我认为这应该适合你。它找到最长的子序列，然后清除其他元素。实现是在c#中

public static void Main() {
    int[][] dataList = {
                        new []{20,30,21,22,23,24,25},
                        new []{30,31,21,22,23,24,25},
                        new []{30,21,22,23,24,25,26},
                        new []{20,21,22,23,18,25,26},
                        new []{20,15,21,22,23,24,25}
                    };

    foreach (var data in dataList)
        DetectAndRemoveUnsorted(data);
}

/// <summary>
/// Assumes ascending data. You can adapt it for descending data too
/// </summary>
static void DetectAndRemoveUnsorted(IList<int> data) {
    // first pass: Find the outliers; rather find the correct sequence
    int startOfLongestSeq = 0, lenOfLongestSeq = 0;
    int startOfCurrSeq = 0, lenOfCurrSeq = 0;
    for (int i = 0; i < data.Count - 1; ++i) {
        if (data[i] > data[i + 1]) { // we are breaking the ascending order, so this is another sequence
            lenOfCurrSeq = i - startOfCurrSeq + 1;
            if (lenOfCurrSeq > lenOfLongestSeq) {
                lenOfLongestSeq = lenOfCurrSeq;
                startOfLongestSeq = startOfCurrSeq;
            }
            startOfCurrSeq = i + 1;
        }
    }

    lenOfCurrSeq = data.Count - startOfCurrSeq;
    if (lenOfCurrSeq > lenOfLongestSeq) {
        lenOfLongestSeq = lenOfCurrSeq;
        startOfLongestSeq = startOfCurrSeq;
    }


    // second pass: cleanup outliers

    // now we know which sequence is the largest
    // we should get rid of the other sequences
    for (int i = startOfLongestSeq - 1; i >= 0; --i)
        data[i] = -1; // Mark them as invalid. if you want, you can delete them as well

    for (int i = data.Count - 1; i >= startOfLongestSeq + lenOfLongestSeq; --i)
        data[i] = -1; // Mark them as invalid. if you want, you can delete them as well
}