Leetcode-15三数之和

C语音版本，暴力版本，这是我开始写的版本。

但是时间和空间都不会通过。

void quickSort(int* nums,int first,int end){
    int temp,l,r;
    if(first>=end)return;
    temp=nums[first];
    l=first;r=end;
    while(l<r){
        while(l<r && nums[r]>=temp)r--;
        if(l<r)nums[l]=nums[r];
        while(l<r && nums[l]<=temp)l++;
        if(l<r)nums[r]=nums[l];
    }
    nums[l]=temp;
    quickSort(nums,first,l-1);
    quickSort(nums,l+1,end);
} //快排代码
int** array(int** dp,int dpSize,int* returnSize )
{
    int **dp1;
    
    int size = sizeof(int *) * dpSize;
    dp1 = (int **)malloc(size);//分配指针数组
    for(int i=0; i<dpSize; i++)
    {
        dp1[i] = (int *)malloc(sizeof(int) * (3));//分配每个指针所指向的数组
    }
   for(int i =0;i<dpSize-1;i++)
   {
       for(int j=i+1;j<dpSize;j++)
       {
           if(dp[i][0]==dp[j][0]&&dp[i][1]==dp[j][1]&&dp[i][2]==dp[j][2])
           {
               dp[j][0]=-1;
               dp[j][1]=-1;
               dp[j][2]=-1;           
           }

       }
   }
   int k =0;
    for(int i =0;i<dpSize;i++)
    {

            if(!(dp[i][0]==-1&&dp[i][1]==-1&&dp[i][2]==-1))
            {
                dp1[k][0]=dp[i][0];
                dp1[k][1]=dp[i][1];
                dp1[k][2]=dp[i][2];
                k++;
            }
            
    }
    *returnSize = k;
    return dp1;
}

int** threeSum(int* nums, int numsSize, int* returnSize) {
    int  num = 0;
    quickSort(nums,0,numsSize-1);
    
    int **dp;
    int l = 0;
    dp = (int **)malloc(sizeof(int *) * (numsSize*(numsSize-1)*(numsSize-2)/6));//分配指针数组
    for(int i=0; i<(numsSize*(numsSize-1)*(numsSize-2)/6); i++)
    {
           dp[i] = (int *)malloc(sizeof(int) * (3));//分配每个指针所指向的数组
    }
    
    int **dp1;
   
   // dp1 = (int **)malloc(sizeof(int *) * (numsSize*(numsSize-1)*(numsSize-2)/6));//分配指针数组
  //  for(int i=0; i<(numsSize*(numsSize-1)*(numsSize-2)/6); i++)
  //  {
  //         dp1[i] = (int *)malloc(sizeof(int) * (3));//分配每个指针所指向的数组
   // }   
    for(int i = 0; i<numsSize-2; i++)
    {
        for(int j = i+1; j<numsSize-1; j++)
        {
            for(int k = j+1; k<numsSize; k++)
            {
                if(nums[i]+nums[j]==-nums[k]&&((nums[k]==nums[k-1]&&nums[j]==nums[j-1]&&nums[k]!=0)!=1))
                {
                    
                    dp[l][0]=nums[i];
                    dp[l][1]=nums[j];
                    dp[l][2]=nums[k];
                    num++;
                    l++;
                }
            }
        }
    }
 dp = array(dp,num,returnSize);
   //*returnSize = num1;
 return dp;
}

暴力求解版本二，依然超时。

void quickSort(int* nums,int first,int end){
    int temp,l,r;
    if(first>=end)return;
    temp=nums[first];
    l=first;r=end;
    while(l<r){
        while(l<r && nums[r]>=temp)r--;
        if(l<r)nums[l]=nums[r];
        while(l<r && nums[l]<=temp)l++;
        if(l<r)nums[r]=nums[l];
    }
    nums[l]=temp;
    quickSort(nums,first,l-1);
    quickSort(nums,l+1,end);
} //快排代码

int** threeSum(int* nums, int numsSize, int* returnSize){
    int  num = 0,t,flag=0;
    quickSort(nums,0,numsSize-1);
#if 1
    int **dp;
    int size = sizeof(int *) * (numsSize*(numsSize-1)*(numsSize-2)/6);
    dp = (int **)malloc(size);//分配指针数组
    for(int i=0; i<numsSize*(numsSize-1)*(numsSize-2)/6; i++)
    {
        dp[i] = (int *)malloc(sizeof(int) * (3));//分配每个指针所指向的数组
    }    
#endif

    int l = 0;
    for(int i = 0; i<numsSize-2; i++)
    {
        for(int j = i+1; j<numsSize-1; j++)
        {
            
            for(int k = j+1; k<numsSize; k++)
            {
                if(nums[i]+nums[j]==-nums[k])
                {
                  
                    
                   
                    dp[l][0]=nums[i];
                    dp[l][1]=nums[j];
                    dp[l][2]=nums[k];
                    for(t=0;t<l;t++)
                    {
                     
                        if((dp[l][0]==dp[t][0])&&(dp[l][1]==dp[t][1]))
                        { 
                            flag=1;
                            break;  
                        } 
                        else
                        {
                            flag=0;    
                        }
                         
                        
                    }
                    
                      if(flag==1)
                    {
                           l=l;
                          num=num; 
                                                
                    }
                    else
                    {                        
                       l++;     
                       num++;
                    }

                   // printf("%d %d %d\n",dp[l][0],dp[l][1],dp[l][2]);
                    //l++;  
                }
            }
        }
    }
       
    *returnSize=num;
    return dp;
}

可通过版本。非暴力求解，有时候方向走错了真的不行啊。思路一定要正确。

void quickSort(int* nums,int first,int end){  

    int temp,l,r;  

    if(first>=end)return;  

    temp=nums[first];  

    l=first;r=end;  

    while(l<r){  

        while(l<r && nums[r]>=temp)r--;  

        if(l<r)nums[l]=nums[r];  

        while(l<r && nums[l]<=temp)l++;  

        if(l<r)nums[r]=nums[l];  

    }  

    nums[l]=temp;  

    quickSort(nums,first,l-1);  

    quickSort(nums,l+1,end);  

} //快排代码,思路：每次挖一个坑，然后看坑里应该放谁，当从两头挖的坑汇聚到一起，坑里的萝卜就是有序的了;

int** threeSum(int* nums, int numsSize, int* returnSize) {  

    int i,sum,top=-1,begin,end;  

    int** res=(int**)malloc(sizeof(int*)*(numsSize*(numsSize-1)*(numsSize-2))/6);//这里的内存分配最大值为c n 3,即排列组合知识;  

    if(numsSize<3){  

        *returnSize=0;  

        return res;  

    }  //组内元素小于三时直接返回;

    quickSort(nums,0,numsSize-1);//快排;  

    for(i=0;i<numsSize;i++){  

        if(nums[i]>0)break;//首元素大于0，跳出for，已经查找到所有符合条件的三元组;  

        if(i>0 && nums[i]==nums[i-1])continue; //与上次判定一致，直接跳过，执行i++; 

        begin=i+1;end=numsSize-1; //固定i后在i+1/尾两处放入指针，开始循环; 

        while(begin<end){  

            sum=nums[i]+nums[begin]+nums[end];  

            if(sum==0){  

                top++;  

                res[top]=(int*)malloc(sizeof(int)*3);  

                res[top][0]=nums[i];res[top][1]=nums[begin];res[top][2]=nums[end];  

                begin++;end--;  

                while(begin<end && nums[begin]==nums[begin-1])begin++;  

                while(begin<end && nums[end]==nums[end+1])end--;  

            }else if(sum>0) end--;  

            else begin++;  

        } //while 

    } //for 

    *returnSize=top+1; //top作为计数器，即为需要返回的长度; 

    return res;  

}  

https://blog.csdn.net/jack_c_monkey/article/details/80469345

上面代码是这个人写的，当时我已经知道思路，就没再写了。

C++代码

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        int i = 0, j = 0, k = 0, target = 0;
        sort(nums.begin(),nums.end());  //对数组进行排序
        for(i = 0; i < nums.size(); i ++){
            if(nums[i] > 0)
                break;
            else if(i > 0 && nums[i] == nums[i - 1])     //跳过重复元素
                continue;
            target = -nums[i];  //更新target，转换为两数之和为target的问题
            j = i+1;
            k = nums.size() -1;
            while(j < k){                
                if(nums[j] + nums[k] == target){
                    result.push_back({nums[i],nums[j],nums[k]});
                    while(nums[j + 1] == nums[j] && j < k) ++j; //跳过重复元素
                    while(nums[k - 1] == nums[k] && j< k) --k;  //跳过重复元素
                    ++j, --k;
                }
                else if(nums[j] + nums[k] > target)
                    --k;
                else
                    ++j;
            }
        }
        return result;
    }
};
--------------------- 
作者：DurableHumor 
来源：CSDN 
原文：https://blog.csdn.net/my_clear_mind/article/details/81540682 

C++版本差不多。这题主要思路要对，不要暴力求解。