谜题：在一次解析中对包含 0 和 1 的数组进行排序。答案

【问题标题】：Puzzle: Sort an array of 0's and 1's in one parse.谜题：在一次解析中对包含 0 和 1 的数组进行排序。
【发布时间】：2013-07-27 21:05:10
【问题描述】：

是否可以在不使用辅助数组的情况下在一次解析中按降序排列仅由 1 和 0 组成的数组？
例如：假设您有一个数组a[]={1,0,0,0,1,0,1}，为此预期的输出将是a[]={1,1,1,0,0,0,0}。

我已经编写了下面的 C 代码，但它在 2 次解析中找到了解决方案。可以优化吗？

void arrange(int a[],int n) {
    int i,count=0;
    for(i=0;i<n;i++) {
            if(a[i]==1)
                    count++;
            a[i]=0;
    }
    for(i=0;i<count;i++) {
            a[i]=1;
    }
}

【问题讨论】：

您在寻找什么样的优化？一次数据传递？
是的，解决方案应该是一次解析。
Parse 和 pass 是不同的东西，即使它们的发音相同（它们可能是某些人的同音字）。您的代码代表一个解析。

标签： c sorting optimization

【解决方案1】：

for (size_t i = 0, count = 0; i < n; i++) {
  if (a[i] == 1) a[count++] = 1;
  if (i >= count) a[i] = 0;
}

【讨论】：

如果 a[0] 最初是 1 怎么办？
糟糕。谢谢，吉姆，我会解决这个问题的。
@Inspired 我认为a[count+=a[i]] |= a[i] 将不再需要第一个if 声明。第二个 if 也可以删除，如果我们将循环分成两个，第一个循环遍历 1 直到遇到 0，第二个循环从那里接替。
@unxnut 那么代码将是无分支的，太好了。在我看来，count 的初始值应该是 -1，因为 a[count+=a[i]] 太早增加了count。
我喜欢这个。这对我来说很不明显，这是正确的:-)

【解决方案2】：

让我试试这个：

void arrange(int a[],int n)
{
    int* p = a;
    int* q = &a[n-1];

    while (p <= q) 
    {
        while (*p == 1 && p <= q) /* Find a Zero, starting from the front */
        {
            ++p;
        }
        while (*q == 0 && p <= q) /* Find a One, starting from the back */
        {
            --q;
        }

        if (p < q) /* *p == Zero, and *q == One, and p is to the left of q. */
        {
            *p = 1; 
            *q = 0;
        }
    }
}

这适用于两个指针，一个从前面开始，另一个从后面开始，它们都向中间移动直到相遇。

一路上，如果两个指针在左边找到一个0，在右边找到一个1，交换值，然后继续。

（代码未经测试，但轮廓看起来很扎实）

【讨论】：

谢谢，我编译好了。它工作正常。当我在参数 n 中发送大小时，我们需要将代码 int* q = &a[n] 更改为 int* q = &a[n-1]
好主意，但似乎有点太复杂了:)
它们确实有道理，但在格式化为评论时却没有。我会将我的代码粘贴到答案中，然后将其删除 - 你可以看到。
@JonathanLeffler;您应该为您的代码制作并附上屏幕截图链接（对于
@hacks：它太大而不能成为一个好的屏幕截图，它是对答案的评论（尽管是一个很大的评论），这就是为什么它被删除为非答案的原因。努力达到 10k，你也可以看到它。 :D

【解决方案3】：

递归呢？一如既往的简洁优雅。

void countAndRewrite(int arr[], size_t n, size_t *cone, size_t total)
{
    if (n) {
        if (arr[0])
            ++*cone;

        countAndRewrite(arr + 1, n - 1, cone, total);
        arr[0] = total - n < *cone;
    }
}

int main()
{
    int arr[] = { 0, 1, 0, 1, 1, 1, 0 };
    size_t cone = 0;
    countAndRewrite(arr, 7, &cone, 7);
    for (size_t i = 0; i < 7; i++)
    printf("arr[%zu] = %d\n", i, arr[i]);

    return 0;
}

【讨论】：

理解起来有点复杂，我通常避免递归解决方案。无论如何感谢您的帮助:)
优雅，是的，但简单？ :) 不错的解决方案。
@Inspired 谢谢！同样，这取决于您的口味 :) 我觉得它很直观。也许我只是忙于实现我的虚拟机，我总是从堆栈的角度思考：P
@H2CO3 好吧，对于二叉树：queue.push(root); while (!queue.empty()) { node = queue.front(); queue.pop(); if (node!=NULL) { process_node(node); queue.push(node->left); queue.push(node->right); } } :)
@Inspired 是的，就是这样！

【解决方案4】：

试一试！

（读取 cmets）：

#include<stdio.h>
int main(void){
    int a[]={1,0,0,0,1,0,1};
    int n = 7,
        i,
        index = 0;

   while(index < n && a[index]) index++; // skip initial 1's
   for(i = index; i < n; i++){  
     if(a[i]) a[index++] = 1; // if `1` at a[i] make its 0 and
     a[i] = 0;                // make at index 1. 
   }

   for(i = 0; i < n; i++){
        printf("%3d", a[i]);
   }
    return 1;
}

检查工作代码@ideone的链接：

案例 1： {1,0,0,0,1,0,1}
案例 2： {1,0,1,1,1,0,0,1,0,1, 1}
案例 3： @987654323 @
案例 4： {0, 0, 0, 0, 0, 0, 0}
案例 5： {0, 0, 0, 1, 1, 1, 1}

所以我认为它是正确的！
很简单，只需要n 迭代。
复杂性明智O(n)。

【讨论】：

我认为1,0,0,1,1,0,1会失败让我检查一下
这对于1,1,1,...,1 将失败（超出while 循环中的数组边界）。
所有解决方案（甚至 2 次通过）的时间复杂度为 O(n)，因为 O(n) = O(2*n)。
@Inspired 是的，它只需要n 迭代甚至没有 2n ..更好一点...不？
@GrijeshChauhan 更好，是的，但仍然是 O(n) 或 O(2*n) 或 O(1000*n)。我只是在强调大O的含义。

【解决方案5】：

只是另一种方式。

有两个枢轴，一个从开始，另一个在结束，如下所示，

for(int i=0, j=n-1;i<j;)
{
if(a[i]==1 && a[j]==0) swap(a[i],a[j]);
else if(a[i]==1 && a[j]==1) j--;
else if(a[i]==0 && a[j]==0) i++;
else if(a[i]==0 && a[j]==1) {j--; i++;}
}

【讨论】：

【解决方案6】：

#include<iostream>

using namespace std;

int main() {
    int arr[] = {1, 1, 1, 1, 1, 0, 0, 0};
    int N = sizeof(arr) / sizeof(arr[0]);
    int p = 0, q = 1;

while (q != N) {
    if (arr[p] > arr[q]) {
        arr[p] = 0;
        arr[q] = 1;
        p++;
        q++;
    }
    else {
        q++;
        if (arr[p] == 0)
            p++;
    }
}

for (int i = 0; i < N; i++)
    cout << arr[i];

return 0;

【讨论】：