題目：Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.
Note: The solution set must not contain duplicate triplets.
For example, given array S = [-1, 0, 1, 2, -1, -4],
A solution set is:
[
[-1, 0, 1],
[-1, -1, 2]
]

public class Solution {
    /** * 015-3 Sum（三個數的和） * * @param nums 輸入的數組 * @return 執行結果 */
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new LinkedList<>();
 
        if (nums != null && nums.length > 2) {
            // 先對數組進行排序
            Arrays.sort(nums);
            // i表示假設取第i個數作為結果
            for (int i = 0; i < nums.length - 2; ) {
                // 第二個數可能的起始位置
                int j = i + 1;
                // 第三個數可能是結束位置
                int k = nums.length - 1;
 
                while (j < k) {
                    // 如果找到滿足條件的解
                    if (nums[j] + nums[k] == -nums[i]) {
                        // 將結果添加到結果含集中
                        List<Integer> list = new ArrayList<>(3);
                        list.add(nums[i]);
                        list.add(nums[j]);
                        list.add(nums[k]);
                        result.add(list);
 
                        // 移動到下一個位置，找下一組解
                        k--;
                        j++;
 
                        // 從左向右找第一個與之前處理的數不同的數的下標
                        while (j < k && nums[j] == nums[j - 1]) {
                            j++;
                        }
                        //從右向左找第一個與之前處理的數不同的數的下標
                        while (j < k && nums[k] == nums[k + 1]) {
                            k--;
                        }
                    }
                    // 和大于0
                    else if (nums[j] + nums[k] > -nums[i]) {
                        k--;
                        // 從右向左找第一個與之前處理的數不同的數的下標
                        while (j < k && nums[k] == nums[k + 1]) {
                            k--;
                        }
                    }
                    // 和小于0
                    else {
                        j++;
                        // 從左向右找第一個與之前處理的數不同的數的下標
                        while (j < k && nums[j] == nums[j - 1]) {
                            j++;
                        }
                    }
                }
 
                // 指向下一個要處理的數
                i++;
                //從左向右找第一個與之前處理的數不同的數的下標
                while (i < nums.length - 2 && nums[i] == nums[i - 1]) {
                    i++;
                }
            }
        }
 
        return result;
    }
}