获取布尔数组中所有假元素索引的最快方法是什么

for 循环可能是最快的方法：

List<int> indices = new List<int>();
for (int i=0;i < theArray.Length; ++i)
{
   if (theArray[i])
   {
       indices.Add(i);
   }
}

请注意，通过预分配List<int>，您可能会以额外内存为代价获得一点速度：

List<int> indices = new List<int>(theArray.Length);

这将避免额外的内存分配。

对于最多 32 个元素：

int mask = 0;
for (int i = 0; i < arr.Length; i++)
{
    if (!arr[i]) mask += 1 << i;
}

掩码

将是一个 32 位掩码，如果该位索引处的元素为 false，则每个位为 1，如果元素为 true，则为 0。如果你想说，它是数组的另一种表示形式，使用四个字节而不是每个布尔值一个字节。对于最多 64 个元素，您可以改用 long 类型。但是，据我所知，使用int您可以将enum变成适当的位掩码。

涉及的总字节数：四个用于掩码，一个用于数组的每个元素，四个用于循环中的索引。完成的总分配：两个(如果我们不计算数组的分配(。

这可能不是最快的方法，但它只产生真实索引的 IEnumerable。 对我来说似乎有点混乱。 我想知道是否可以简化？ for 循环可能是最好的。 但对于它的价值：

var bools = new bool[] {true, false, true, true, false, false, true, false, true};
var falseIndices = bools.Select((b, i) => new { Index = i, Value = b })
                        .Where(o => !o.Value)
                        .Select(o => o.Index);

在你获得经验证据之前，你永远不会知道什么是最快的解决方案。可以使用下一个代码作为 LINQ 和for循环方法的计算速度比较的参考：

var r = new Random();
bool[] vals = new bool[100000000];
//initializing
for (int i = 0; i < vals.Length; i++)
{
    vals[i] = r.Next(2)==0;
}
var watch = Stopwatch.StartNew();
//for loop benchmark
List<int> indices = new List<int>(vals.Length);
for(int i = 0; i < vals.Length; ++i)
{
    if(!vals[i])
        indices.Add(i);
}
Console.WriteLine ("for loop: {0} ms", watch.ElapsedMilliseconds);
watch.Restart();
//LINQ benchmark
List<int> falseIndices = vals.Where(flag => !flag)
                             .Select((flag, index) => index)
                             .ToList();
Console.WriteLine ("LINQ: {0} ms", watch.ElapsedMilliseconds);  

打印一些东西：

for loop: 600 ms
LINQ: 2072 ms

最快的方法可能包括使用 fixed 固定数组。但是，结果代码的可读性不是很强。

您应该确保"查找false元素的索引"确实是应用程序中的瓶颈，并且找到"最快的方法"确实可以改善它。可读性和可维护性也是相当重要的方面。

正如其他人所建议的那样，简单的 for 循环具有良好的性能并且非常可读。Linq 解决方案不会慢得多。

如果数组包含大量true而不是很多false则可以考虑对每个false使用 Array.IndexOf()，直到不再出现。它可能比每元素方法更快。

我也

做了一些时间安排，它表明人们所说的是正确的：使用指针并不比简单循环快得多。

我怀疑仅填充结果列表就占用了最多的时间。

这是我从以下测试程序中得到的时间：

Unsafe took 00:00:06.6450271
Safe   took 00:00:06.7691818

测试代码如下...

using System;
using System.Collections.Generic;
using System.Diagnostics;
namespace Demo
{
    class Program
    {
        void Run()
        {
            int size = 10000000;
            bool[] array = new bool[size];
            for (int i = 0; i < size - 1; ++i)
                array[i] = true;
            int count = 100;
            time(() => UnsafeCountSetFlags(array), "Unsafe", count);
            time(() => SafeCountSetFlags(array),   "Safe",   count);
        }
        void time(Action action, string title, int count)
        {
            var sw = Stopwatch.StartNew();
            for (int i = 0; i < count; ++i)
                action();
            Console.WriteLine(title + " took " + sw.Elapsed);
        }
        List<int> UnsafeCountSetFlags(bool[] array)
        {
            unsafe
            {
                fixed (bool* parray = array)
                {
                    List<int> result = new List<int>();
                    for (bool* p = parray, end = parray + array.Length; p != end; ++p)
                        if (*p)
                            result.Add((int)(p-parray));
                    return result;
                }
            }
        }
        List<int> SafeCountSetFlags(bool[] array)
        {
            List<int> result = new List<int>();
            for (int i = 0; i < array.Length; ++i)
                if (array[i])
                    result.Add(i);
            return result;
        }
        static void Main()
        {
            new Program().Run();
        }
    }
}

尝试以下操作：

    BlockingCollection<int> indexes = new BlockingCollection<int>(x.Length);
    Parallel.For(0, x.Length, i =>
    {
        if (x[i])
        {
            indexes.Add(i);
        }
    });