如何检查字节数组是否包含另一个数组

Question

我有一个很长的字节数组，例如：

Byte[] bytes = {90, 80, 63, 65, 70 ...};

大约 20-30 Mb（理论上）。有没有一种快速的方法来检查这个数组是否包含另一个数组，例如：

Byte[] small = {63, 80, 75, 77};

首先，我需要按照它们在小数组中定义的顺序查找字节。其次，我需要在另一个数组中找到数组，而不是小数组的任何字节。 谢谢大家的进步。

Answer 1

你可以使用这个函数，来自this Reddit post：

public static bool CheckSequence<T>(IEnumerable<T> containingArray, IEnumerable<T> containedArray)
{
    bool result = false;
    for (int i = 0; i <= containingArray.Count(); i++)
    {
        if (containedArray.SequenceEqual(containingArray.Skip(i).Take(containedArray.Count())))
            result = true;
    }
    return result;
}

喜欢：

var result = CheckSequence(bytes, small);

Answer 2

如果我理解正确，您想说small 是否是bytes 的子序列。您可以通过字节循环找到它。由于处理器缓存，它应该运行得非常快。

  for (int i = 0, index = 0; i < bytes.Length; ++i) 
    if (bytes[i] == small[index]) {
      if (++index >= small.Length) {
        return true; 
      }
    }
  return false;

Answer 3

为了提高性能，您需要Boyer-Moore string search algorithm 之类的东西。虽然它是为字符串设计的，但它在字节数组上也应该同样适用，并且比暴力解决方案性能要好得多。

Wikipedia 文章提供了几种实现，包括一种用 Java 编写的，一种用 C 编写的，因此创建 C# 实现应该相当轻松。

---

事实证明，将 Wikipedia 文章中的 Boyer-Moore 的 Java 实现翻译成 C#（以及将 char 翻译成 byte）确实很轻松。这里是：

public static class BoyerMoore
{
    public static int IndexOf(byte[] haystack, byte[] needle)
    {
        if (needle.Length == 0)
        {
            return 0;
        }

        int[] charTable = MakeCharTable(needle);
        int[] offsetTable = MakeOffsetTable(needle);
        for (int i = needle.Length - 1; i < haystack.Length;)
        {
            int j;
            for (j = needle.Length - 1; needle[j] == haystack[i]; --i, --j)
            {
                if (j == 0)
                {
                    return i;
                }
            }

            i += Math.Max(offsetTable[needle.Length - 1 - j], charTable[haystack[i]]);
        }

        return -1;
    }

    private static int[] MakeCharTable(byte[] needle)
    {
        const int ALPHABET_SIZE = 256;
        int[] table = new int[ALPHABET_SIZE];
        for (int i = 0; i < table.Length; ++i)
        {
            table[i] = needle.Length;
        }

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

        return table;
    }

    private static int[] MakeOffsetTable(byte[] needle)
    {
        int[] table = new int[needle.Length];
        int lastPrefixPosition = needle.Length;
        for (int i = needle.Length - 1; i >= 0; --i)
        {
            if (IsPrefix(needle, i + 1))
            {
                lastPrefixPosition = i + 1;
            }

            table[needle.Length - 1 - i] = lastPrefixPosition - i + needle.Length - 1;
        }

        for (int i = 0; i < needle.Length - 1; ++i)
        {
            int slen = SuffixLength(needle, i);
            table[slen] = needle.Length - 1 - i + slen;
        }

        return table;
    }

    private static bool IsPrefix(byte[] needle, int p)
    {
        for (int i = p, j = 0; i < needle.Length; ++i, ++j)
        {
            if (needle[i] != needle[j])
            {
                return false;
            }
        }

        return true;
    }

    private static int SuffixLength(byte[] needle, int p)
    {
        int len = 0;
        for (int i = p, j = needle.Length - 1; i >= 0 && needle[i] == needle[j]; --i, --j)
        {
            len += 1;
        }

        return len;
    }
}

该算法在开始时会花费一些线性时间来构建其表；从那时起，它的速度非常快。

Answer 4

使用这个：

bool isSubset = !t2.Except(t1).Any();

来自@Farhad Jabiyev 的链接： Check whether an array is a subset of another

Answer 5

static int search(byte[] haystack, byte[] needle)
{
    for (int i = 0; i <= haystack.Length - needle.Length; i++)
    {
        if (match(haystack, needle, i))
        {
            return i;
        }
    }
    return -1;
}

static bool match(byte[] haystack, byte[] needle, int start)
{
    if (needle.Length + start > haystack.Length)
    {
        return false;
    }
    else
    {
        for (int i = 0; i < needle.Length; i++)
        {
            if (needle[i] != haystack[i + start])
            {
                return false;
            }
        }
        return true;
    }
}

Answer 6

如果您有数百万字节的元素，我建议：

1. 对字节排序
2. foreach in small 如果找不到元素返回 false

这样

bytes.Sort(); // only need to do this once.
bool smallContained = ContainsAll(bytes, small);

和

static bool ContainsAll(int[] src, int [] subset)
{ 
    foreach(var i in subset)
       if (src.BinarySearch(i) < 0)
               return false;
    return true;
}