比较高效地实现从两个不同数组中提取相同部分组成新的数组(暂时只支持Int类型)

有时候我们需要从两个不同数组中提取出相同的部分的数组或者计算有多少个相同的项，这个算法刚好能派上用场，

实现方案：
1、将两个数组按从小到大排序；
2、遍历第一个数组 array1，跟第二个数组 array2 做比较；
3、如果找到相等的则提取出该数据并且记录下 array2 的下标到临时变量 t，下次循环则从 array2[t+1] 开始遍历 array2；
4、如果没有匹配到相等的而且 array2[t] 大于与 array1 对比的数据时, 记下 array2 当前下标到临时变量 t，下次循环则从 array2[t] 开始；

经过测试，该算法比“最笨”的作法无法在数组以何种方式排序都要强，如果量越多会越明显，有点可惜的是暂时只能使用在 Int[] 上，有时间再想一下其它数据类型的比较

获取两个整型数组中相等项的集合
获取两个整型数组中相等项的集合#region  获取两个整型数组中相等项的集合

/**//// <summary>
/// 获取两个整型数组中相等项的集合
/// </summary>
/// <param name="array1"></param>
/// <param name="array2"></param>
/// <returns></returns>
public static int[] CompareEquation(int[] array1, int[] array2)
{
    int i1, i2;
    // 记录第二个数组上一次匹配到的位置
    int t = 0;
    // 记录相同的项
    List<int> equal = new List<int>();

    int[] sort1 = BubbleSort(array1);
    int[] sort2 = BubbleSort(array2);

    for (int i = 0; i < sort1.Length; i++)
    {
        i1 = sort1[i];

        for (int j = t; j < sort2.Length; j++)
        {
            i2 = sort2[j];

            if (i2 == i1)
            {
                equal.Add(i2);
                // 下次比较从下一位开始
                t = j + 1;
            }
            else if (i2 > i1)
            {
                // 下次比较继续从这里开始
                t = j;
                break;
            }
        }
    }

    return equal.ToArray();
}

#endregion

冒泡法排序(非原创)
冒泡法排序(非原创)#region 冒泡法排序(非原创)

/**//// <summary>
/// 冒泡法排序
/// </summary>
/// <returns>排序结果: 从小到大(升序)</returns>
/// <see cref="http://www.aspcool.com/lanmu/browse1.asp?ID=1223&bbsuser=csharp"/>
public static int[] BubbleSort(int[] R)
{
    int i, j, temp;
    //交换标志 
    bool exchange;
    //最多做R.Length-1趟排序 
    for (i = 0; i < R.Length; i++)
    {
        //本趟排序开始前，交换标志应为假 
        exchange = false;
        for (j = R.Length - 2; j >= i; j--)
        {
            //交换条件 
            if (R[j + 1] < R[j])
            {
                temp = R[j + 1];
                R[j + 1] = R[j];
                R[j] = temp;
                //发生了交换，故将交换标志置为真 
                exchange = true;
            }
        }
        //本趟排序未发生交换，提前终止算法 
        if (!exchange)
        {
            break;
        }
    }

    return R;
}

#endregion

测试结果：



所谓的最笨的方法：

自我感觉最笨的作法
计算两个整型数组中数值相等的数量(最笨的方法)#region 计算两个整型数组中数值相等的数量(最笨的方法)

/**//// <summary>
/// 计算两个整型数组中数值相等的数量(最笨的方法)
/// </summary>
/// <param name="array1"></param>
/// <param name="array2"></param>
/// <returns></returns>
public static int[] CompareEquation1(int[] array1, int[] array2)
{
    List<int> equal = new List<int>();

    foreach (int i1 in array1)
    {
        foreach (int i2 in array2)
        {
            if (i1 == i2)
            {
                equal.Add(i1);
            }
        }
    }
    return equal.ToArray();
}

#endregion

从图中可以看到运行效率有了很大的提升，
以上只是不成熟的解决方案，欢迎各位一起来讨论!

相关代码下载