从更大的列表中筛选出无序int列表

Question

我得到了一个无序列表。在80到140个项目之间，每个项目的值在0到175之间。

我正在生成该列表的列表，其中大约有5到1000万。

我需要尽快处理所有唯一有序的序列（不包括重复项）。

我现在的操作方式是创建列表所有值的哈希，然后将其插入到哈希集中。

分析时的两个热点是ToArray（） HOTSPOT1 和Array.Sort（） HOTSPOT2

是否有更好的方法来完成该任务，或者有更好的替代方法来修复这两个热点？速度很重要。

小型演示，我尝试尽可能多地复制

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp1
{

    class Example
    {
        //some other properties

        public int Id { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var checkedUnlock = new HashSet<int>();
            var data = FakeData();

            foreach (List<Example> subList in data)
            {
                var hash = CalcHash(subList.Select(x => x.Id).ToArray());  // HOTPSOT1

                var newHash = checkedUnlock.Add(hash);

                if (newHash)
                {
                    //do something
                }
            }
        }

        static int CalcHash(int[] value)
        {
            Array.Sort(value); // HOTPSOT2

            int hash;
            unchecked // https://stackoverflow.com/a/263416/40868
            {
                hash = (int)2166136261;
                var i = value.Length;
                while (i-- > 0)
                    hash = (hash * 16777619) ^ value[i];
            }

            return hash;
        }

        //don't look at this, this is just to fake data
        static List<List<Example>> FakeData()
        {
            var data = new List<List<Example>>();

            var jMax = 10; //normally between 80 and 140
            var idMax = 25; //normally between 0 and 175
            var rnd = new Random(42);
            var ids = Enumerable.Range(0, idMax).ToArray();

            for (int i = 0; i < 500000; ++i)
            {
                //force duplicate
                if(i % 50000 == 0)
                {
                    ids = Enumerable.Range(0, idMax).ToArray();
                    rnd = new Random(42);
                }

                for (int r = 0; r < idMax; ++r)
                {
                    int randomIndex = rnd.Next(idMax);
                    int temp = ids[randomIndex];
                    ids[randomIndex] = ids[r];
                    ids[r] = temp;
                }

                var subList = new List<Example>();
                data.Add(subList);

                for (int j = 0; j < jMax; ++j)
                {
                    subList.Add(new Example() { Id = ids[j] });                    
                }
            }

            return data;
        }
    }
}

Answer 1

因此，您有一个最多可以包含140个项目的数组，并且所有值都在0到175之间。数组中的所有值都是唯一的，顺序无关紧要。也就是说，数组[20, 90, 16]将被视为与[16, 20, 90]相同。

鉴于此，您可以将一个数组表示为一组175位。更好的是，您可以创建集合而不必对输入数组进行排序。

您将C＃中的集合表示为BitArray。要计算数组的哈希码，请创建集合，然后遍历集合以获取哈希码。看起来像这样：

private BitArray HashCalcSet = new BitArray(175);
int CalcHash(int[] a, int startIndex)
{
    // construct the set
    HashCalcSet.SetAll(false);

    for (var i = startIndex; i < a.Length; ++i)
    {
        HashCalcSet[a[i]] = true;
    }

    // compute the hash
    hash = (int)2166136261;
    for (var i = 174; i >= 0; --i)
    {
        if (HashCalcSet[i])
        {
            hash = (hash * 16777619) ^ value[i];
        }
    }
    return hash;
}

这消除了排序和ToArray。您必须在BitArray上循环几次，但是在BitArray上进行三遍传递可能比排序更快。

我对您的解决方案看到的一个问题是您如何使用HashSet。您有以下代码：

var hash = CalcHash(subList.Select(x => x.Id).ToArray());  // HOTPSOT1

var newHash = checkedUnlock.Add(hash);

if (newHash)
{
    //do something
}

该代码错误地假设，如果两个数组的哈希码相等，则数组相等。您正在生成一个175位数量的32位哈希码。肯定会有哈希冲突。您最终会说，两个数组不同时，它们是相同的。

如果您对此感到担心，请告诉我，我可以编辑答案以提供解决方案。

允许比较

如果您希望能够比较项目是否相等，而不仅仅是检查其哈希码是否相同，则需要创建一个具有Equals和GetHashCode方法的对象。您将把该对象插入HashSet中。这些对象中最简单的对象将包含上文所述的BitArray以及对其进行操作的方法。像这样：

class ArrayObject
{
    private BitArray theBits;
    private int hashCode;
    public override bool Equals(object obj)
    {
        if (object == null || GetType() != obj.GetType())
        {
            return false;
        }
        ArrayObject other = (ArrayObject)obj;
        // compare two BitArray objects
        for (var i = 0; i < theBits.Length; ++i)
        {
            if (theBits[i] != other.theBits[i])
                return false;
        }
        return true;
    }

    public override int GetHashCode()
    {
        return hashCode;
    }

    public ArrayObject(int hash, BitArray bits)
    {
        theBits = bits;
        hashCode = hash;
    }
}

这样的想法是，您按照上述方法构造BitArray和哈希码（尽管您必须为每个调用分配一个新的BitArray），然后创建并返回这些ArrayObject实例之一。

您的HashSet成为HashSet<ArrayObject>。

以上方法有效，但它占用了大量内存。您可以通过创建仅包含三个long整数的类来减少内存需求。您无需直接使用BitArray，而直接操作这些位。您映射这些位，以便数字0到63修改第一个数字中的位0到63。数字64到127对应于第二个数字的位0到63，以此类推。因此，您不必保存单独的哈希码，因为从三个long中进行计算很容易，并且相等比较变得容易得多也是如此。

该类看起来像这样。理解，我还没有测试代码，但是这个想法应该是正确的。

class ArrayObject2
{
    private long l1;
    private long l2;
    private long l3;

    public ArrayObject2(int[] theArray)
    {
        for (int i = 0; i < theArray.Length; ++i)
        {
            var rem = theArray[i] % 63;
            int bitVal = 1 << rem;
            if (rem < 64) l1 |= bitVal;
            else if (rem < 128) l2 |= bitVal;
            else l3 |= bitVal;
        }
    }

    public override bool Equals(object obj)
    {
        var other = obj as ArrayObject2;
        if (other == null) return false;
        return l1 == other.l1 && l2 == other.l2 && l3 == other.l3;
    }

    public override int GetHashCode()
    {
        // very simple, and not very good hash function.
        return (int)l1;
    }
}

正如我在代码中评论的那样，哈希函数并不是很好。它将起作用，但是通过一些研究您可以做得更好。

此方法的优点是使用的内存少于BitArray或Boolean数组。它可能会比bool的数组慢。它可能比BitArray代码快。但是无论如何，它都可以使您避免错误地假设相同的哈希码等于相同的数组。

Answer 2

我认为您可以通过重用一个更大的数组来节省一些时间，而不必每次都分配新的数组而导致额外的内存通信和垃圾回收。

这将需要自定义排序实现，该实现知道即使数组可以有1000个项目，但对于当前运行，仅需要对前80个项目进行排序（散列也是如此）。在id的子范围上运行的quicksort看起来应该可以正常工作。快速的想法样本（尚未经过详细测试）

int[] buffer = new int[1000];
foreach (List<Example> subList in data)
{
    for (int i = 0; i < subList.Count; i++)
    {
        buffer[i] = subList[i].Id;
    }
    var hash = CalcHashEx(buffer, 0, subList.Count - 1);

    var newHash = checkedUnlock.Add(hash);

    if (newHash)
    {
        //do something
    }
}


public static void QuickSort(int[] elements, int left, int right)
{
    int i = left, j = right;
    int pivot = elements[(left + right) / 2];
    while (i <= j)
    {
        while (elements[i] < pivot)
        {
            i++;
        }
        while (elements[j] > pivot)
        {
            j--;
        }
        if (i <= j)
        {
            // Swap
            int tmp = elements[i];
            elements[i] = elements[j];
            elements[j] = tmp;
            i++;
            j--;
        }
    }

    if (left < j)
    {
        QuickSort(elements, left, j);
    }
    if (i < right)
    {
        QuickSort(elements, i, right);
    }
}

static int CalcHashEx(int[] value, int startIndex, int endIndex)
{
    QuickSort(value, startIndex, endIndex);

    int hash;
    unchecked // https://stackoverflow.com/a/263416/40868
    {
        hash = (int)2166136261;
        var i = endIndex + 1;
        while (i-- > 0)
            hash = (hash * 16777619) ^ value[i];
    }

    return hash;
}

Answer 3

此版本的CalcHash()可让您删除.ToArray()并用可以对序列起作用的不同东西替换Array.Sort()，而不需要整个集合...所以两个热点。

static int CalcHash(IEnumerable<int> value)
{
    value = value.OrderByDescending(i => i);

    int hash;
    unchecked // https://stackoverflow.com/a/263416/40868
    {
        hash = (int)2166136261;
        foreach(var item in value)
        {
            hash = (hash * 16777619) ^ item;
        }
    }

    return hash;
}

我不确定OrderByDescending()的表现如何。我怀疑它会比Array.Sort()慢一些，但由于消除了ToArray()而仍然是一个全面的胜利...但是您需要再次运行探查器才能确定。

通过.GroupBy()消除或减少分支，并在每个组的.First()项目上运行代码，您可能还会得到一些改进：

var groups = data.GroupBy(sub => CalcHash(sub.Select(x => x.Id)));
foreach(List<Example> subList in groups.Select(g => g.First()))
{
    //do something
}

Answer 4

将其放在此处，因为将其放在注释中没有意义

到目前为止，我所做的是创建一个布尔数组并将存在时将该项目的索引设置为true，然后我将CalcHash替换为；

        unchecked
        {
            hash = (int)2166136261;
            var i = theMaxLength;
            while (i-- > 0)
                if(testing[i]) //the array of boolean
                {
                    hash = (hash  * 16777619) ^ i;
                    testing[i] = false;
                }
        }

这样做是为了彻底删除ToArray（）和Array.Sort（），此解决方案是根据dlxeon / jim / joel答案构建的

我将运行时减少了大约20-25％，这很好