我写了一个C#类,用一些数据填充“双打列表列表”(无论数据是什么,现在它可能只是一些垃圾:)),用于测试目的：

这是代码：

class test
    {
    public test()
    {
       _mylistofList = new List<List<double>>(1000000);
    }
    public void Run()
    {
        for (int i = 0; i < _mylistofList.Capacity; i++)
        {
            _mylistofList.Add(
                new List<double>(3) { i,10*i,100*i}
                ); //Populate the list with data
        }
    }

    private List<List<double>> _mylistofList;
}

我将此代码的执行速度与以下内容进行了比较:(用元组替换double的列表)

class test
    {
    public test()
    {
       _mylistofTuple = new List<Tuple<double,double,double>>(1000000);
    }
    public void Run()
    {
        for (int i = 0; i < _mylistofTuple.Capacity; i++)
        {
            _mylistofTuple.Add(
                new Tuple<double,double>(i,10 * i,100 * i)
                ); //Populate the list with data
        }
    }

    private List<Tuple<double,double>> _mylistofTuple;
}

事实证明,使用元组似乎要快得多.我为不同的List大小运行了这段代码(从200,000个元素 – 列表中的> 5百万个元素),这是我得到的结果：

我无法真正理解这一点.为什么我会有如此显着的差异？使用存储相同类型对象的元组(这里加倍)并没有多大意义.我宁愿使用List /数组来做到这一点：我做错了什么？是否有一种方法可以使案例#1以比案例#2更快/更快的速度运行？

谢谢！

新元组< double,100 * i)和新List< double>(3){i,100 * i}之间存在差异.

第一个是超级简单 – 只有3个任务：

public Tuple(T1 item1,T2 item2,T3 item3) {
    m_Item1 = item1;
    m_Item2 = item2;
    m_Item3 = item3;
}

第二个实际上是由编译器转换为3个Add方法调用：

var temp = new List<double>(3);
temp.Add(i);
temp.Add(10 * i);
temp.Add(100 * i);

添加不仅仅是一项任务：

public void Add(T item) {
    if (_size == _items.Length) EnsureCapacity(_size + 1);
    _items[_size++] = item;
    _version++;
}

运行更多代码,执行速度更慢.非常简单..

有

List<byte> lbyte

有

byte[] searchBytes

如何搜索lbyte不仅仅是一个字节,而是搜索searchBytes的索引？
例如.

Int32 index = lbyte.FirstIndexOf(searchBytes);

这是我提出的蛮力.
不是我要找的表现.

public static Int32 ListIndexOfArray(List<byte> lb,byte[] sbs)
{
    if (sbs == null) return -1;
    if (sbs.Length == 0) return -1;
    if (sbs.Length > 8) return -1;
    if (sbs.Length == 1) return lb.FirstOrDefault(x => x == sbs[0]);
    Int32 sbsLen = sbs.Length;
    Int32 sbsCurMatch = 0;
    for (int i = 0; i < lb.Count; i++)
    {
        if (lb[i] == sbs[sbsCurMatch])
        {
            sbsCurMatch++;
            if (sbsCurMatch == sbsLen)
            {
                //int index = lb.Findindex(e => sbs.All(f => f.Equals(e)));  // fails to find a match
                IndexOfArray = i - sbsLen + 1;
                return;
            }
        }
        else 
        {
            sbsCurMatch = 0;
        }
    }
    return -1;
}

你可能会发现 Boyer-Moore algorithm在这里很有用.将列表转换为数组并进行搜索.算法代码取自 this post.

static int SimpleBoyerMooreSearch(byte[] haystack,byte[] needle)
{
    int[] lookup = new int[256];
    for (int i = 0; i < lookup.Length; i++) { lookup[i] = needle.Length; }

    for (int i = 0; i < needle.Length; i++)
    {
        lookup[needle[i]] = needle.Length - i - 1;
    }

    int index = needle.Length - 1;
    var lastByte = needle.Last();
    while (index < haystack.Length)
    {
        var checkByte = haystack[index];
        if (haystack[index] == lastByte)
        {
            bool found = true;
            for (int j = needle.Length - 2; j >= 0; j--)
            {
                if (haystack[index - needle.Length + j + 1] != needle[j])
                {
                    found = false;
                    break;
                }
            }

            if (found)
                return index - needle.Length + 1;
            else
                index++;
        }
        else
        {
            index += lookup[checkByte];
        }
    }
    return -1;
}

然后你可以这样搜索.如果lbyte在一段时间后保持不变,你可以将它转换为一个数组并传递它.

//index is returned,or -1 if 'searchBytes' is not found
int startIndex = SimpleBoyerMooreSearch(lbyte.ToArray(),searchBytes);

根据评论更新.这是IList实现,这意味着可以传递数组和列表(以及实现IList的任何其他内容)

static int SimpleBoyerMooreSearch(IList<byte> haystack,IList<byte> needle)
 {
    int[] lookup = new int[256];
    for (int i = 0; i < lookup.Length; i++) { lookup[i] = needle.Count; }

    for (int i = 0; i < needle.Count; i++)
    {
        lookup[needle[i]] = needle.Count - i - 1;
    }

    int index = needle.Count - 1;
    var lastByte = needle[index];
    while (index < haystack.Count)
    {
        var checkByte = haystack[index];
        if (haystack[index] == lastByte)
        {
            bool found = true;
            for (int j = needle.Count - 2; j >= 0; j--)
            {
                if (haystack[index - needle.Count + j + 1] != needle[j])
                {
                    found = false;
                    break;
                }
            }

            if (found)
                return index - needle.Count + 1;
            else
                index++;
        }
        else
        {
            index += lookup[checkByte];
        }
    }
    return -1;
}

由于数组和列表实现了IList,因此在您的情况下调用它时不需要进行转换.

int startIndex = SimpleBoyerMooreSearch(lbyte,searchBytes);