C# 两个数组求相同值

两个数组：
string[] str1 = new string[] { "1", "2", "3", "4", "6", "9", "10" };
string[] str2 = new string[] { "1", "3", "4", "6", "8", "11" };
求两个数组的相同值
string[] str3 = new string[]{"1", "3", "4", "6"};
方法一：一步到位

  string[] str1 = new string[] { "1", "2", "3", "4", "6", "9", "10" };
  string[] str2 = new string[] { "1", "3", "4", "6", "8", "11" };
  string[] str3 = str1.Where(t => str2.Contains(t)).ToArray();

方法二：以空间换取时间
1，扫描数组str1，将其值作为key，值为1。如dic.Add(key,1)
2，扫描数组str2，将其值作为key，与Dictionary的key比较，若key相等，设置dic的值为0
3，扫描Dictionary，若值为0，则key为str1与str2相等的值。

 string[] str1 = new string[] { "1", "2", "3", "4", "6", "9", "10" };
            string[] str2 = new string[] { "1", "3", "4", "6", "8", "11" };
           
            //string[] str3 = str1.Where(t => str2.Contains(t)).ToArray();

            ArrayList array = new ArrayList();
            Dictionary<string, int> dic = new Dictionary<string, int>();
            for (int i = 0; i < str1.Length; i++)
            {
                dic.Add(str1[i], 1);
            }
            for (int i = 0; i < str2.Length; i++)
            {
                if (dic.ContainsKey(str2[i]))
                {
                    dic[str2[i]] = 0;
                }
            }
            foreach (string key in dic.Keys)
            {
                if (dic[key] == 0)
                {
                    array.Add(key);
                }
            }

 方法三，自定义数组
使用快速排序算法，将两个数组排序，然后进行比较
具体算法如下

 public int[] Fun(int[] a,int[] b)
        {
            if(a.Length == 0 || b.Length == 0)
            {
                return null;
            }//两个数组不为空
            int aIndex = 0;
            int bIndex = 0;
            int cIndex = 0;
            Sort(a, 0, a.Length - 1);
            Sort(b, 0, b.Length - 1);//排序
            int[] c = new int[a.Length > b.Length ? a.Length : b.Length];//定义一个新数组
            for(; aIndex < a.Length; aIndex++)
            {//遍历a数组
                while(bIndex < b.Length && a[aIndex] >= b[bIndex])//查找b数组中的相同项
                {
                    if(a[aIndex] == b[bIndex])
                    {//有相等
                        c[cIndex] = a[aIndex];//插入数组c
                        bIndex++;//b索引下标加1
                        cIndex++;//c索引下标加1
                        break;
                    }
                    else if(a[aIndex] > b[aIndex])
                    {//a>b
                        bIndex++;//b索引下标加1，继续while循环
                    }
                    else//b>a,退出循环，比较a的下一个
                    {
                        break;
                    }

                }
            }
            for(int i = 0; i < cIndex; i++)//打印
            {
                Console.WriteLine(c[i]);
            }
            return c;//返回结果
        }

        public void Sort(int[] intArray, int nLower, int nUpper)
        {
            if(nLower < nUpper)
            {
                int nSplit = Partition(intArray, nLower, nUpper);
                ///递归排序
                Sort(intArray, nLower, nSplit - 1);
                Sort(intArray, nSplit + 1, nUpper);
            }
        }

        /// <summary>
        /// 方法参数：原始数组、第一个元素位置、最后元素位置
        /// 方法功能：完成一趟快速排序
        /// </summary>
        /// <param name="intArray"></param>
        /// <param name="nLower"></param>
        /// <param name="nUpper"></param>
        /// <returns></returns>
        public int Partition(int[] intArray, int nLower, int nUpper)
        {
            int nLeft = nLower + 1;
            ///以数组第一个元素值作为支点
            int nPivot = intArray[nLower];
            int nRight = nUpper;

            int nSwap;
            while(nLeft <= nRight)
            {
                ///从左向右寻找大于支点元素
                while(nLeft <= nRight && intArray[nLeft] < nPivot)
                    nLeft++;
                ///从右向左寻找小于支点元素
                while(nLeft <= nRight && intArray[nRight] >= nPivot)
                    nRight--;
                ///交换nLeft和nRight位置元素值
                if(nLeft < nRight)
                {
                    nSwap = intArray[nLeft];
                    intArray[nLeft] = intArray[nRight];
                    intArray[nRight] = nSwap;
                    nLeft++;
                    nRight--;
                }
            }
            ///以intArray[nRight]为新支点 
            nSwap = intArray[nLower];
            intArray[nLower] = intArray[nRight];
            intArray[nRight] = nSwap;
            return nRight;
        }