LeetCode--15.三数之和

解题思路：

        1.获取信息：

                （1）题目要求：取出一个数组中所有，三个数相加等于0的组合

                （2）限制条件：不能有重复的组合

        2.分析题目：（像这样给出信息，没有啥隐含信息或需要推导出来新信息的题，我这一环节基本都是空着的，不然写出来就太冗杂了，不利于你理解）

                我还是按我一开始的思路给你讲，一直到最后我得出其他方法，层层递进，可以让你不会太突兀，已经很贴心了，另外下面的方法的排序也是很有讲究的，按我想出的先后顺序进行排序

        3.示例查验：

                示例1：输出顺序和三元组的顺序并不重要（我给你鲜明的例子帮助你理解）

                        如：-1，0，1这三个数，可以以 [ -1, 0, 1 ]或者 [ 1, 0, -1]等顺序储存在其中，不影响结果

                        如：[ -1, 0, 1]和[ 0, 0, 0]这两个三元组，返回的顺序可以是[ [ -1, 0, 1], [ 0, 0, 0] ]或者[ [ 0, 0, 0], [ -1, 0, 1] ]，都可以，不会影响结果

        4.尝试编写代码：

                （1）暴力法：找出这个数组中三个数的所有组合，再将符合条件的组合加入到结果中即可

               优点：无脑易懂，所以就不写注释咯，稍微偷懒一下，另外这是我第一次尝试写，还没有优化

                缺点：缺点不小，由于是O(n*n*n)，会超时的

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>>res;
        vector<int>path;
        int size=nums.size()-1;
        for(int i=0;i<=size;i++){
            for(int j=i+1;j<=size;j++){
                for(int n=j+1;n<=size;n++){
                    if(nums[i]+nums[j]+nums[n]==0){
                        if(nums[i]>=nums[j]){
                            if(nums[n]>=nums[i]){
                                path.push_back(nums[n]);
                                path.push_back(nums[i]);
                                path.push_back(nums[j]);
                            }else{
                                if(nums[n]>=nums[j]){
                                    path.push_back(nums[i]);
                                    path.push_back(nums[n]);
                                    path.push_back(nums[j]);
                                }else{
                                    path.push_back(nums[i]);
                                    path.push_back(nums[j]);
                                    path.push_back(nums[n]);
                                }
                            }
                        }else{
                            if(nums[n]>=nums[j]){
                                path.push_back(nums[n]);
                                path.push_back(nums[j]);
                                path.push_back(nums[i]);
                            }else{
                                if(nums[n]>=nums[i]){
                                    path.push_back(nums[j]);
                                    path.push_back(nums[n]);
                                    path.push_back(nums[i]);
                                }else{
                                    path.push_back(nums[j]);
                                    path.push_back(nums[i]);
                                    path.push_back(nums[n]);
                                }
                            }
                        }
                        if(find(res.begin(),res.end(),path)==res.end()){
                            res.push_back(path);
                        }
                        path.clear();
                    }
                }
            }
        }
        return res;
    }
};

                （2）暴力法（优化版）（动态规划加双指针）

                                优化思路：我们在进行第二层循环和第三层循环时，无非就是在第一层循环的基础上取两数之和，那么就比较简单了，要两个数求和来获取一个目标值

                                考虑到两数求和，我们可以提前将数组按从小到大的顺序排列好

                                因为不是只求一种组合，所以不能用二分查找法，但可以用动态规划的思想

                                使用双指针，其中一个指针的初始位置放在第一层循环初始位置的下一位元素，另一个指针放在数组最后一个元素上

                                那么此时，无非就三种情况

                                1.两者相加等于目标值，那就将这三个元素合并成数组加入结果中

                                2.两者相加大于目标值，那么将放在数组右边的指针左移一位

                                3.两者相加小于目标值，那么将放在数组左边的指针右移一位

                                重复上述操作，即可求出最后结果，以下是完整代码

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());//对数组进行排序
        vector<vector<int>>res;//储存结果的容器
        int size=nums.size();//数组的大小
        for(int i=0;i<size;i++){//一层循环
            if(i>0&&nums[i]==nums[i-1])continue;//跳过重复的数，优化时间和空间
            int p1=i+1,p2=size-1;//将指针放在该放的位置
            int target=-nums[i];//二数求和的目标值
            while(p1<p2){//终止条件
                int sum=nums[p1]+nums[p2];//两指针指向元素的和
                if(target==sum){//
                    res.push_back({nums[i],nums[p1],nums[p2]});
                    while(p1<p2&&nums[p1]==nums[p1+1])p1++;
                    while(p1<p2&&nums[p2]==nums[p2-1])p2--;
                    p1++;
                    p2--;
                }else if(target>sum){
                    p1++;
                }else{
                    p2--;
                }
            }
        }
        return res;
    }
};

好吧，其实我今天做到了16题了，看看晚点我会发出来吗？也许会，也许不会吧

还是，纸上得来终觉浅，绝知此事要躬行