4Sum

4sum算法：

　　这一类的算法要想进行时间复杂度的缩减，都必须先将数组进行简单的排序。然后依次固定两个数据，再对剩余的数据进行从两端开始的循环，固定的连个数据加上剩余数据的两端的数据之和等于目标数据的时候，说明查找成功，保存记录。当小于目标数据时，已经知道数据是有序的（假定是升序排列），低位坐标low++，这样可以保证4个数据之和比先前的要大，若是大于目标数据时，则高位进行high--。当low》=high，跳出while循环，退出到外层循环，改变固定的数据，进行下一个while循环。

void QSort(int *s,int low,int high){
    int i=low;
    int j=high;
    if(i>=j)return ;
    int key=s[i];
    while(i<j){
        while(i<j&&key<s[j])j--;
        s[i]=s[j];
        while(i<j&&key>=s[i])i++;
        s[j]=s[i];
    }
    s[i]=key;
    QSort(s,low,i-1);
    QSort(s,i+1,high);
}
int** fourSum(int* nums, int numsSize, int target, int* returnSize) {
    int low;
    int high;
    int count=0;
    int** res=(int**)malloc(sizeof(int*)*(numsSize*numsSize));
    if(nums==NULL||numsSize==0)return res;
    int* temp;
    int sum=0;
    int flag=0;
     QSort(nums,0,numsSize-1);
     for(int i=0;i<numsSize-3;i++){
         //判断处理，去掉相邻重复的两个数据的重复操作 
         if (i > 0 && nums[i] == nums[i-1]) continue; 
         for(int j=i+1;j<numsSize-2;j++){
             //同样是去掉重复操作 
             if(flag!=0&&nums[j]==nums[j-1]){
                 continue ;
             }
            flag++;
             low=j+1;
             high=numsSize-1; 
             while(low<high){
                 sum=nums[i]+nums[j]+nums[low]+nums[high];
                 if(sum==target){
                     temp=(int*)malloc(sizeof(int)*4);
                     temp[0]=nums[i];
                     temp[1]=nums[j];
                     temp[2]=nums[low];
                     temp[3]=nums[high];
                     res[count++]=temp;
                     //同样的去掉重复操作 
                     while(low<high&&nums[low]==nums[low+1])low++;
                     while(low<high&&nums[high]==nums[high-1])high--;
                     low++;
                     high--;
                 }
                 else if(sum>target)high--;
                 else low++;    
             }
         }
        flag=0; 
    }
     
    *(returnSize)=count;
     return res;   
}