大数据---集合交集和并集

1.有两个大数据 Array1和数组Array2：求两个数组的交集：

•    1）.时间复杂度o(N*M) 空间复杂度o(1)；

public static void test1(int array1[],int array2[])
    {// 暴力解法
        List<Integer> E=new ArrayList<>();
        for(int i=0;i<array1.length;i++)
            for(int j=0;j<array2.length;j++)
            {
                if(array2[j]==array1[i])
                    E.add(array2[j]);
            }
                
    }

•  2）. 双排序后进行比较 排序完毕后 如果array1[index1]>array2[index2] 则index2++; 否则的话index1++ ,相同的话将其放入到容器ArrayList中

算法复杂度分析 排序（桶排序算法时间复杂度 o(MlogM) ）+遍历的时间= o(N*log(N)+M*log(M))+o(min(N,M)) 对其进行进一步的理解：

public static void test2(int array1[],int array2[])
    {
        
        //1.使用快速排序
        quick(array1,0,array1.length-1);// 使用Arrays数组中的方法
        
       //2.使用Arrays数组中sort方法---使用快速排序
        Arrays.sort(array2);
        
        
        List<Integer> E=new ArrayList<>();
        
        int index1=0,index2=0;
        int length=Math.min(array1.length,array2.length);
     while(index1<length && index2<length)
     {
         if(array1[index1]==array2[index2])
         {
             E.add(array1[index1]);
             index1++;index2++;
         }
         else if(array1[index1]>array2[index2])
             index2++;
         else
             index1++;
     }
     
     for(int i=0;i<E.size();i++)
         System.out.print(E.get(i)+" ");
    }

对快速排序的方法：

public static void quick(int array[],int low,int hight)
    {//叫做 挖坑填补+分治法
         if(low<hight)
         {
             int middle=getMiddle(array,low,hight);
             quick(array,low,middle-1);// 对低的表进行递归
             quick(array,middle+1,hight);//对较高的表进行递归
         }
    }
    public static int getMiddle(int array[],int start,int end)
    {//一次遍历下来 Key小的在前方，比Key值大在后面
         int temp=array[start];
         while(start<end)
         {
             while(start<end && array[end]>temp)
                 end--;
             array[start]=array[end];
             
             while(start<end && array[start]<temp)
                 start++;
             array[end]=array[start];
             
         }
         array[start]=temp;
         return start;
    }

• 3）使用哈希表：将两组数据放入到哈希表中，最后只需要变量哈希集合就可以得到：空间o(N+M) 时间复杂度o(N+M)
• 当然这些解决冲突封装在hashMap,HashTable 中

在数据散列的时候 有两种方法解决冲突Hash=x mod N ; 集合中的数据随机的，不同的随机数散列到同一个地址，不得不解决位置冲突

      第一种分离链接法:在产生冲突时候 使用LinkedList存取冲突的数据：一般表的大小选择 接近o(N+M)最近的素数

     第二种：开放地址方法：装填因子<=0.5 超过不得不扩大表的大小2*TableSize+1，一旦发生冲突：使用线性方法，或者平方的方法大的数据表中 找新的位置来解决冲突

public static void test3(int array1[],int array2[])
    {
        // 通过HashMap:求两个集合中交集
        Map<Integer,Integer> map=new HashMap<>();
        
        for(int i=0;i<Math.min(array1.length,array2.length);i++)
        {
            contains(map,array1[i]);
            contains(map,array2[i]);
        }
        
        // 遍历
        for(Map.Entry<Integer, Integer>m:map.entrySet())
        {
            if(m.getValue()>1)
                System.out.println(m.getKey());
        }
    }
    
    public static void contains(Map<Integer,Integer>map,int k)
    {
        if(map.containsKey(k))
        {
            int tmp=map.get(k);
            tmp++;
            map.put(k, tmp);
        }
        else
        {
            map.put(k,1);
        }
    }

当数据集特别大的时候可以使用MapReduce的过程的处理，Mapreduce 的原理是一个归并排序---使用数据量大但是数据种类小的

用N个Map任务和一个reduce任务，对原始数据进行分组，通过hash(item)%N将数组中的数据分到各个Map任务中

每个MAp任务求每个子集的交集处理。

  归并排序：将两个以上的有序表合并成一个新的有序表，可以用于内排序同时运用于外排序 一种稳定的排序方式，无论最好还是最坏的情况O(NlogN)，辅助空间o(N)

public static void contains(Map<Integer,Integer>map,int k)
    {
        if(map.containsKey(k))
        {
            int tmp=map.get(k);
            tmp++;
            map.put(k, tmp);
        }
        else
        {
            map.put(k,1);
        }
    }
    
    public static void Merger_sort(int array[],int start,int end)
    {
        if(start>=end)
            return;
        int Mid=(start+end)/2;
        
        Merger_sort(array,start,Mid);
        Merger_sort(array,Mid+1,end);
        int[]m=Merger(array,start,Mid,end);
        
        for(int i=0;i<m.length;i++)
        {
            System.out.println(m[i]);
        }
        System.out.println();
    }

    private static int[] Merger(int[] a, int left, int mid, int right) {
        int r1=mid+1;
        int tmp[]=new int[a.length];
        
        int tIndex = left;
        int cIndex=left;
        // 逐个归并
        while(left <=mid && r1 <= right) {
            if (a[left] <= a[r1]) 
                tmp[tIndex++] = a[left++];
            else
                tmp[tIndex++] = a[r1++];
        }
            // 将左边剩余的归并
            while (left <=mid) {
                tmp[tIndex++] = a[left++];
            }
            // 将右边剩余的归并
            while ( r1 <= right ) {
                tmp[tIndex++] = a[r1++];
            }
            
            int i=0;
            System.out.println("第"+(++i)+"趟排序:	");
            // TODO Auto-generated method stub
            //从临时数组拷贝到原数组
             while(cIndex<=right){
                    a[cIndex]=tmp[cIndex];
                    //输出中间归并排序结果
                    System.out.print(a[cIndex]+"	");
                    cIndex++;
                }
             System.out.println();
        return a;
    }