15 Somme de trois nombres (tri + trois pointeurs)

1. Description du problème:

Donnez-vous un tableau de n nombres entiers, déterminez s'il y a trois éléments a, b, c dans nums, de sorte que a + b + c = 0? Veuillez trouver tous les triplets qui remplissent la condition et ne répétez pas.

Remarque: La réponse ne peut pas contenir de triplets en double.

Exemples:

Étant donné le nombre de tableaux = [-1, 0, 1, 2, -1, -4],

L'ensemble des triplets répondant aux exigences est le suivant:
[
  [-1, 0, 1],
  [-1, -1, 2]
]

Source:
Lien (LeetCode) : https://leetcode-cn.com/problems/3sum

2. Analyse de la pensée:

① Le sujet est toujours facile à comprendre. Avant, je faisais une somme à quatre chiffres de la boucle du collier . La méthode d'utilisation de quatre pointeurs est similaire aux quatre pointeurs précédents, vous pouvez donc utiliser trois Utilisez des pointeurs pour le faire. Si vous utilisez d'autres méthodes pour le faire, cela est plus gênant et il est facile de temporiser. Par exemple, si les données récursives sont petites, elles peuvent être résolues. Il expirera et il est gênant de récursivement s'il y a beaucoup de données en double.

② Tout d'abord, vous devez trier le tableau afin de pouvoir retirer les éléments et juger s'ils sont répétés plus tard. Au début, le premier pointeur pointe vers la position du premier élément et le deuxième pointeur pointe vers le deuxième élément. La position de l'élément suivant, le troisième pointeur pointe vers la position du dernier élément, puis ces positions se déplaceront vers le bas dans la boucle. Il convient de noter que le problème nécessite des nombres uniques. Par conséquent, il est nécessaire de déterminer la déduplication en premier pendant le recyclage, car lorsque les éléments sont identiques, quel élément est retiré et ajouté est le même

③ Si les éléments actuellement ajoutés en a, b et c sont inférieurs à 0, le pointeur b se déplace d'un bit vers la droite et s'il est supérieur à 0, c se déplace d'un bit vers la gauche. Lors du déplacement, vous devez vous assurer que b est inférieur à c. La position du nombre est correcte. Lorsque le résultat de l'addition est égal à 0, vous devez alors passer à l'élément suivant qui se répète avec les éléments b et c (pour vous assurer que l'élément suivant retiré des positions b et c n'est pas répété), b Décalage à droite, décalage à gauche

④ Donc, au début, l'élément en position a doit être dédupliqué, mais au début, la position b n'a pas besoin d'être dédupliquée, car la position b sera dédupliquée lorsque l'élément ajouté est égal à 0, donc au début, le poids en position b Lorsque l'élément est égal à 0, cela entraînera des jugements répétés et expirera. Je suis également allé à l'élément b au début, mais j'ai constaté que les deux dernières données de test sur la soumission avaient expiré. b position poids

3. Le code est le suivant:

class Solution {
   public static List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        int len = nums.length;
        for (int a = 0; a <= len - 3; ++a){
            //优化
            if (nums[a] > 0) return res;
            //去重
            if (a > 0 && nums[a] == nums[a - 1]) continue;
            int b = a + 1, c = len - 1;
            while (b < c){
                int target = nums[a] + nums[b] + nums[c];
                if (target < 0) ++b;
                else if (target > 0) --c;
                else {
                    List<Integer> newEle = new ArrayList<>();
                    newEle.add(nums[a]);
                    newEle.add(nums[b]);
                    newEle.add(nums[c]);
                    res.add(newEle);
                    //去重
                    while (b < c && nums[b] == nums[b + 1]) ++b;
                    //去重
                    while (b < c && nums[c] == nums[c - 1]) --c;
                    ++b;
                    --c;
                }
            }
        }
        return res;
    }
}