Arrays 给出一个O（N）算法来重新排列真/假列表，使所有假元素位于真之前

我有一个由N个元素组成的数组，其中只包含两个不同的键，true和false。我正在尝试编写一个O（N）算法来重新排列列表，以便所有假元素都位于真元素之前。该算法的一个具体要求是，我只能遍历数组一次（这意味着我不能在数组上进行两次遍历；一次用于计算真/假的数量，另一次用于向数组赋值）。我也不允许创建外部临时数组

---

最初我想使用计数排序，但意识到我不能这样做，因为这个赋值的要求是我不能创建外部/临时数组

然后，由于只有两个可能的值，我想迭代一次并计算它们。然后重复第二次并设置顺序（进行排序）。然而，我也不能这样做，因为我只能做一次迭代

因此，我自己正在尝试实现一种算法，该算法只在数组中迭代一次，同时进行排序。到目前为止，我的想法如下（这只是一个或多或少以伪代码形式编写的想法）

array=tf
int len=数组的长度。
计数器=0
用于数组中的项
计数器+=1
如果计数器希望下面的答案有帮助

internal void ArrangeBooleanArray()
    {
        bool[] inputArray = {false, true, true, false};
        int arrayLength = inputArray.Length;
        bool[] outputArray = new bool[arrayLength];
        int trueCount = 0;
        int falseCount = 0;            

        foreach (var item in inputArray)
        {
            if (item == true)
            {
                trueCount++;
                outputArray[arrayLength - trueCount] = item;                    
            }
            else
            {
                outputArray[falseCount] = item;
                falseCount++;
            }
        }
    }

希望下面的答案有帮助

internal void ArrangeBooleanArray()
    {
        bool[] inputArray = {false, true, true, false};
        int arrayLength = inputArray.Length;
        bool[] outputArray = new bool[arrayLength];
        int trueCount = 0;
        int falseCount = 0;            

        foreach (var item in inputArray)
        {
            if (item == true)
            {
                trueCount++;
                outputArray[arrayLength - trueCount] = item;                    
            }
            else
            {
                outputArray[falseCount] = item;
                falseCount++;
            }
        }
    }

您可以尝试快速排序的想法：从数组的开始和结束同时遍历数组，并交换顺序不正确的元素。也就是说，如果在数组的左半部分发现
true
，请将其与右半部分的
false
交换

因为你只有两个不同的值，一次就足够了

例如：

bool[] array = ...;
int low = 0;
int high = array.Length - 1;
do
{
    while (array[low] == false)
        low++;

    while (array[high] == true)
        high--;

    if (low <= high)
    {
        bool temp = array[low];
        array[low] = array[high];
        array[high] = temp;
    }
}
while (low < high);

bool[]数组=。。。；
int低=0；
int高=数组。长度-1；
做
{
while（数组[低]==false）
低++；
while（数组[高]==真）
高--；
if（low您可以尝试快速排序的想法：同时从开始和结束遍历数组，并交换顺序不正确的元素。例如，如果在数组的左半部分发现
true
，则在右半部分将其与
false
交换

因为你只有两个不同的值，一次就足够了

例如：

bool[] array = ...;
int low = 0;
int high = array.Length - 1;
do
{
    while (array[low] == false)
        low++;

    while (array[high] == true)
        high--;

    if (low <= high)
    {
        bool temp = array[low];
        array[low] = array[high];
        array[high] = temp;
    }
}
while (low < high);

bool[]数组=。。。；
int低=0；
int高=数组。长度-1；
做
{
while（数组[低]==false）
低++；
while（数组[高]==真）
高--；
如果（低简明地说：

swap = 0
for index in range(len(list)):
    if list[index] != true:
        list[index], list[swap] = list[swap], list[index]
        swap += 1

简而言之：

swap = 0
for index in range(len(list)):
    if list[index] != true:
        list[index], list[swap] = list[swap], list[index]
        swap += 1

保留一个索引（
lastFalseIdx
），在其中插入
False
元素。因此，最初它是0。从左到右遍历数组，如果找到
False
，则将其与
lastFalseIdx
处的元素交换，并增加索引

Python（几乎是伪代码）：

保留一个索引（
lastFalseIdx
）以插入
False
元素。因此，初始值为0。从左到右遍历数组，如果找到
False
，则将其与
lastFalseIdx
处的元素交换，并增加索引

Python（几乎是伪代码）：

这里有一个部分解决方案，它在一个单独的数组中构造正确的输出。您可以通过观察初始化
output=input
时发生的情况来推断内联实现

#!/usr/bin/python

input = [False, True, False, False, True, True, False, True, False]

def sort2(input):
    i_false = 0
    i_true = len(input) - 1

    output = [None] * len(input)
    for (i, val) in enumerate(input):
        if val:
            output[i_true]  = True
            i_true -= 1
        else:
            output[i_false] = False
            i_false += 1
    return output

print sort2(input)

在对数组进行一次前向传递后，您就得到了所需的输出。
这里有一个部分解决方案，可以在单独的数组中构造正确的输出。您可以通过观察初始化
output=input
时发生的情况来推断内联实现

#!/usr/bin/python

input = [False, True, False, False, True, True, False, True, False]

def sort2(input):
    i_false = 0
    i_true = len(input) - 1

    output = [None] * len(input)
    for (i, val) in enumerate(input):
        if val:
            output[i_true]  = True
            i_true -= 1
        else:
            output[i_false] = False
            i_false += 1
    return output

print sort2(input)

经过一个数组后，你就有了想要的输出。
如果你从前面和后面同时迭代，当你在中间遇到时停止，这算是两次迭代吗？不，这不算是两次迭代。本来我想使用计数排序，但是我意识到我不能这么做。因为这个任务是，我不能创建一个额外的/临时的数组。如果你从前面和后面同时迭代，当你在中间遇到时停止，这算是两次迭代吗？不，这不算是两次迭代。本来我想使用计数排序，但是我意识到我不能这么做，因为这个ASIG的要求。这是因为我不能创建一个额外/临时数组。我喜欢这个想法，但这会把所有错误的元素放在前面吗？据我所知，这只会将F更改为T，将T更改为F。@OmarN:它不会更改任何内容，相反，它会将值定位在输出数组中的正确位置。Python中的实现可能更简单可读性强于文本描述。我喜欢这个想法，但这会将所有错误元素放在前面吗？据我所知，这只会将F更改为T，将T更改为F。@OmarN:它不会更改任何内容，而是将值定位在输出数组中的正确位置。Python中的实现可能比文本描述。你能用外行英语解释一下这个代码是做什么的吗？我只是想确保我正确地理解了。你能用外行英语解释一下这个代码是做什么的吗？我只是想确保我正确地理解了。