Their thinking

Sort + Double pointer

1. Sort
2. Set three pointers ,i,lp,rp.i Responsible for traversing the array ,lp and rp Be responsible for finding the remaining two numbers .
3. if nums[i]>0, Because it's sorted , So there can't be three numbers that add up to 0, Return directly and jump out of the loop .
4. For repeating elements ： skip , Avoid duplicate solutions
5. Set the left pointer to i+1, The right pointer is n-1. When L<R when , Execute loop ：
   When nums[i]+nums[L]+nums[R]==0, Execute loop , Judge whether the left and right bounds are repeated with the next position , Remove duplicate solutions . At the same time L,RL,R Move to the next position , Looking for new solutions .
   If sum is greater than 0, explain nums[R] Too big ,R Move left
   If sum is less than 0, explain nums[L] Too small ,L Move right

public List<List<Integer>> threeSum(int[] nums) {
    
        List<List<Integer>> result = new ArrayList<>();
        int n = nums.length;
// 1. Sort 
        Arrays.sort(nums);
// 2. Traverse all data index
        for (int i = 0; i < n; i++) {
    
            if(nums[i]>0)
                break;
            // duplicate removal 
            if(i>0 && nums[i]==nums[i-1])
                continue;
            int lp = i + 1;
            int rp = n - 1;
            while (lp < rp){
    
                int sum = nums[i] + nums[lp] + nums[rp];
                if(sum < 0) {
    
                    lp++;
                }else if(sum > 0){
    
                    rp--;
                }else{
    
                    result.add(Arrays.asList(nums[i],nums[lp],nums[rp]));
                    lp++;
                    rp--;
                    // duplicate removal 
                    while (lp < rp && nums[lp]==nums[lp-1]) lp++;
                    while (lp < rp && nums[rp]==nums[rp+1]) rp--;
            }
        }
    }
        return result;
    }