Mise en œuvre du langage leecode - C - 15. Somme des trois chiffres - - - - - idées à améliorer

Un.、Titre

2.、Comment résoudre le problème

（1）Idées à améliorer

Par exemple, le tableau est：{
    -1,0,1,0,3}

（1）Construire un-10^5À10^5Tableau de,Mettez les données un par un dans,Pour la commodité de l'écriture-5À5.

（2）Définir plusieurs variables lors de la mise en place enregistrer les indices Max et Min et les index.

Valeur numérique：-5  -4  -3  -2  -1  0  1  2  3  4  5
Nombre de fois： 0   0   0   0   1  1  1  0  1  0  0
Index： 0   1   2   3   4  5  6  7  8  9  10
                      min         max
                      temp
Longueur du tableau：11
MinIndex = 4
MaxIndex = 6
TempIndex = 4
MaxValue = 3
MinValue = -1

（3）Si la valeur minimale est supérieure à zéro,Indique que la façon dont le tableau est additionné ne peut pas être0,Renvoie une valeur nulle.

（4）Si la valeur maximale est inférieure à zéro,Indique que la façon dont le tableau est additionné ne peut pas être0,Renvoie une valeur nulle.

（5）Si le double du minimum plus le maximum est toujours supérieur à0,Expliquez que ce maximum n'est certainement pas dans la dernière réponse.

-1 * 2 + 3 > 0
MaxIndexMoins un
MaxIndex = 6

（5）.Si le double du maximum plus le minimum est toujours inférieur à0, .Expliquez que ce minimum n'est certainement pas dans la réponse finale .

（6）Logique de jugement：MaxValue  + MinValue + TempValue = 0,Notez - le.TempIndexPour5 .
             -1 + 1 + 0 = 0

（7）Encore une fois. TempIndex=5La valeur correspondante est1, Description il n'y a qu'un seul dans le tableau 0, Et ne coïncide pas avec les valeurs maximales et minimales ,Conformité aux exigences.
    MaxIndexMoins un
    MaxIndex = 6
     Tableau 2D final ajouter un tableau ：{
    {
    -1  0  1 } }
    
（8）Encore une fois.： 
     MinValue : -1 , MaxValue :  0 ,  TempValue :  1 
     DécouverteTempValue :  1 Plus queMaxValue :  0, Pour les éléments répétitifs ,Sortez!.

（9）Encore une fois.：
     MinValue :  0 , MaxValue :  1 , TempValue : -1 
     DécouverteTempValue :  1 Plus queMinValue :  0, Pour les éléments répétitifs ,Sortez!.

（10）Encore une fois.：     
     MinValue :  0 , MaxValue :  0 , TempValue :  0 
     Découverte0Il n'y a que deux valeurs, C'est ici qu'on l'a pris trois fois ,Sortez!.

Trois、VSCode d'essai

（1） Idées à améliorer

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define ELEMENTSIZE 3
#define INITARRAYSIZE 10000
#define RECORDARRAYSIZE 10

void PrintfArr(void *arr, int size, int elementsize);
void PrintfHeadVal();
void Printf2DimensionArray(int** Array, int num1, int num2);

int** threeSum(int* nums, int numsSize, int* returnSize, int** returnColumnSizes);

int main()
{
    
    int nums[] = {
     -1,0,1,0,3 };
    int numsSize = sizeof(nums) / sizeof(int);
    int returnSize = 0;
    int** returnColumnSizes = (int**)malloc(sizeof(int*));
    PrintfArr(nums, numsSize, sizeof(int));
    threeSum(nums, numsSize, &returnSize, returnColumnSizes);
    return 0;
}

/* Par exemple, le tableau est： Valeur numérique：-5 -4 -3 -2 -1 0 1 2 3 4 5 Nombre de fois： 0 1 2 1 3 1 0 2 4 5 1 Index： 0 1 2 3 4 5 6 7 0 9 10 min max temp Longueur du tableau：11 （1）Construire un-10^5À10^5Tableau de,Mettez les données un par un dans. （2） Définir deux variables lors de la mise en place enregistrer les indices Max et Min . （3）Si la valeur minimale est supérieure à zéro,Indique que la façon dont le tableau est additionné ne peut pas être0,Renvoie une valeur nulle. （4）Si la valeur maximale est inférieure à zéro,Indique que la façon dont le tableau est additionné ne peut pas être0,Renvoie une valeur nulle. （5） Ce qui signifie qu'il y a trois variables ,MaxIndex,MinIndex,TempIndex. （6）Logique de jugement：maxValeur + minValeur + tempValeur = 0,Notez - le.. maxValeur + minValeur + tempValeur ！= 0,Non enregistré. （7）min <= 0, max >= 0, tempValeur = 0 - minValeur - maxValeur,Pour jugertemp Index bits for . （8）temp Le BIT d'index correspondant est 0,Si Pour0,Non enregistré. Pour1 Pour déterminer si et max、minCoïncidence, Sortie coïncidente , Ne pas chevaucher les enregistrements .Plus grand que2,Enregistrement. */

int** threeSum(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    
    *returnSize = 0;
    if (numsSize < ELEMENTSIZE)
    {
    
        return NULL;
    }
   
    int** ResArray = (int**)malloc(sizeof(int*) * INITARRAYSIZE);
    int* RecordArray = (int*)malloc(sizeof(int) * (RECORDARRAYSIZE * 2 + 1));
    *returnColumnSizes = (int*)malloc(sizeof(int) * INITARRAYSIZE);
    int MaxIndex = RECORDARRAYSIZE + nums[0];
    int MinIndex = RECORDARRAYSIZE + nums[0];
    int TempValue = 0;
    int MaxValue = MaxIndex - RECORDARRAYSIZE;
    int MinValue = MinIndex - RECORDARRAYSIZE;
    int TempIndex = 0;
    int i = 0;
    int j = 0;
    int Flag = 0;

    //Initialiser le tableauRecordArray
    for ( i = 0; i < RECORDARRAYSIZE * 2 + 1; i++)
    {
    
        RecordArray[i] = 0;
    }

    //Oui.nums Les valeurs du tableau sont enregistrées dans le tableau RecordArrayMoyenne
    // Enregistrer la valeur minimale maximale et l'index 
    for ( i = 0; i < numsSize; i++)
    {
    
        MaxValue = MaxIndex - RECORDARRAYSIZE;

        if (nums[i] > MaxValue)
        {
    
            MaxIndex = RECORDARRAYSIZE + nums[i];
        }

        MinValue = MinIndex - RECORDARRAYSIZE;

        if(nums[i] < MinValue)
        {
    
            MinIndex = RECORDARRAYSIZE + nums[i];
        }
        RecordArray[RECORDARRAYSIZE + nums[i]]++;
    }
    MaxValue = MaxIndex - RECORDARRAYSIZE;
    MinValue = MinIndex - RECORDARRAYSIZE;

    PrintfHeadVal();
    printf("Valeur numérique：");
    PrintfArr(RecordArray, RECORDARRAYSIZE * 2 + 1, sizeof(int));
    printf("MaxIndex : %d , MaxValue : %d , MinIndex : %d , MinValue : %d\n", MaxIndex, MaxValue, MinIndex, MinValue);

    //Si la valeur minimale est supérieure à zéro,Indique que la façon dont le tableau est additionné ne peut pas être0,Renvoie une valeur nulle.
    //Si la valeur maximale est inférieure à zéro,Indique que la façon dont le tableau est additionné ne peut pas être0,Renvoie une valeur nulle.
    if (MaxValue < 0)
    {
    
        return NULL;
    }

    if (MinValue > 0)
    {
    
        return NULL;
    }

    // Ces deux cycles ci - dessous peuvent réduire l'arrière forNombre de cycles, Accélérer l'efficacité du programme .
    //Non, ça ira., Pas très efficace .

    while ((MinValue * 2 + MaxValue > 0) && (RecordArray[MaxIndex] != 0))
    {
    
        MaxIndex--;
        MaxValue = MaxIndex - RECORDARRAYSIZE;
    }

    while ((MinValue + MaxValue * 2 < 0) && (RecordArray[MinIndex] != 0))
    {
    
        MinIndex++;
        MinValue = MinIndex - RECORDARRAYSIZE;
    }

    for (i = MinIndex; i <= RECORDARRAYSIZE; i++)
    {
    
        if (RecordArray[i] == 0)
        {
    
            continue;
        }
        
        MinValue = i - RECORDARRAYSIZE;

        while ((MinValue * 2 + MaxValue > 0) && (RecordArray[MaxIndex] != 0))
        {
    
            MaxIndex--;
            MaxValue = MaxIndex - RECORDARRAYSIZE;
        }

        for ( j = MaxIndex; j >= RECORDARRAYSIZE; j--)
        {
    
            if (RecordArray[j] == 0)
            {
    
                continue;
            }

            MaxValue = j - RECORDARRAYSIZE;
            TempValue = 0 - MinValue - MaxValue;
            TempIndex = TempValue + RECORDARRAYSIZE;

            printf(" i : %2d , MinValue : %2d ,j : %2d , MaxValue : %2d , TempIndex : %2d , TempValue : %2d , RecordArray[TempIndex] : %2d\n",
                     i, MinValue, j, MaxValue, TempIndex, TempValue, RecordArray[TempIndex]);


            if (RecordArray[TempIndex] > 0)
            {
    
                if ((RecordArray[TempIndex] == 1) && (j > TempIndex) && (i < TempIndex))
                {
    
                    Flag = 1;
                }
                else if ((RecordArray[TempIndex] == 2) && (j > TempIndex) && (i <= TempIndex))
                {
    
                    Flag = 1;
                }
                else if ((RecordArray[TempIndex] == 2) && (j >= TempIndex) && (i < TempIndex))
                {
    
                    Flag = 1;
                }
                else if ((RecordArray[TempIndex] > 2) && (j >= TempIndex) && (i <= TempIndex))
                {
    
                    Flag = 1;
                }

                if (Flag)
                {
    
                    printf("*returnSize : %d\n", *returnSize);
                    (*returnColumnSizes)[*returnSize] = ELEMENTSIZE;//*returnColumnSizesEntre parenthèses
                    ResArray[*returnSize] = (int*)malloc(sizeof(int) * ELEMENTSIZE);
                    ResArray[*returnSize][0] = MinValue;
                    ResArray[*returnSize][2] = MaxValue;
                    ResArray[*returnSize][1] = TempValue;
                    //printf("data : (%d , %d , %d)\n", ResArray[*returnSize][0], ResArray[*returnSize][2], ResArray[*returnSize][1]);
                    (*returnSize)++;
                    Printf2DimensionArray(ResArray, *returnSize, ELEMENTSIZE);
                    printf("+++++++++++++++++++++++++++++\n");
                    Flag = 0;
                }
            }
        }
    }
    Printf2DimensionArray(ResArray, *returnSize, ELEMENTSIZE);
    Printf2DimensionArray(returnColumnSizes, 1, *returnSize);
    return ResArray;
}

void Printf2DimensionArray(int** Array, int num1, int num2)
{
    
    int i, j;
    printf("{");
    for ( i = 0; i < num1; i++)
    {
    
        printf("{");
        for ( j = 0; j < num2; j++)
        {
    
            printf("%2d ", Array[i][j]);
        }
        printf("} ");

    }
    printf("} \n");
}

void PrintfHeadVal()
{
    
    int i;
    printf("En - tête：");
    for (i = -RECORDARRAYSIZE; i <= RECORDARRAYSIZE; i++)
    {
    
        printf("%3d ", i);
    }
    printf("\n");
    printf("Index：");
    for (i = 0; i <= RECORDARRAYSIZE * 2 ; i++)
    {
    
        printf("%3d ", i);
    }
    printf("\n");
}

void PrintfArr(void *arr, int size, int elementsize)
{
    
    if (elementsize == sizeof(int))
    {
    
        int *tmparr = (int*)arr;
        int i;
        for (i = 0; i < size; i++)
        {
    
            printf("%3d ", tmparr[i]);
        }
    }
    else if (elementsize == sizeof(char))
    {
    
        char *tmparr = (char*)arr;
        int i;
        for (i = 0; i < size; i++)
        {
    
            printf("%c ", tmparr[i]);
        }
    }
    printf("\n========================\n");
}

Quatre、VSRésultats des opérations

Cinq、leecodeCode de soumission

#define ELEMENTSIZE 3
#define INITARRAYSIZE 20000
#define RECORDARRAYSIZE 100000

int** threeSum(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    
    *returnSize = 0;
    if (numsSize < ELEMENTSIZE)
    {
    
        return NULL;
    }
    int** ResArray = (int**)malloc(sizeof(int*) * INITARRAYSIZE);
    int* RecordArray = (int*)malloc(sizeof(int) * (RECORDARRAYSIZE * 2 + 1));
    *returnColumnSizes = (int*)malloc(sizeof(int) * INITARRAYSIZE);
    int MaxIndex = RECORDARRAYSIZE + nums[0];
    int MinIndex = RECORDARRAYSIZE + nums[0];
    int TempValue = 0;
    int MaxValue = MaxIndex - RECORDARRAYSIZE;
    int MinValue = MinIndex - RECORDARRAYSIZE;
    int TempIndex = 0;
    int i = 0;
    int j = 0;
    int Flag = 0;
    for ( i = 0; i < RECORDARRAYSIZE * 2 + 1; i++)
    {
    
        RecordArray[i] = 0;
    }
    for ( i = 0; i < numsSize; i++)
    {
    
        MaxValue = MaxIndex - RECORDARRAYSIZE;

        if (nums[i] > MaxValue)
        {
    
            MaxIndex = RECORDARRAYSIZE + nums[i];
        }

        MinValue = MinIndex - RECORDARRAYSIZE;

        if(nums[i] < MinValue)
        {
    
            MinIndex = RECORDARRAYSIZE + nums[i];
        }
        RecordArray[RECORDARRAYSIZE + nums[i]]++;
    }
    MaxValue = MaxIndex - RECORDARRAYSIZE;
    MinValue = MinIndex - RECORDARRAYSIZE;
    if (MaxValue < 0)
    {
    
        return NULL;
    }
    if (MinValue > 0)
    {
    
        return NULL;
    }
    while ((MinValue * 2 + MaxValue > 0) && (RecordArray[MaxIndex] != 0))
    {
    
        MaxIndex--;
        MaxValue = MaxIndex - RECORDARRAYSIZE;
    }

    while ((MinValue + MaxValue * 2 < 0) && (RecordArray[MinIndex] != 0))
    {
    
        MinIndex++;
        MinValue = MinIndex - RECORDARRAYSIZE;
    }
    for (i = MinIndex; i <= RECORDARRAYSIZE; i++)
    {
    
        if (RecordArray[i] == 0)
        {
    
            continue;
        }
        MinValue = i - RECORDARRAYSIZE;
        while ((MinValue * 2 + MaxValue > 0) && (RecordArray[MaxIndex] != 0))
        {
    
            MaxIndex--;
            MaxValue = MaxIndex - RECORDARRAYSIZE;
        }
        for ( j = MaxIndex; j >= RECORDARRAYSIZE; j--)
        {
    
            if (RecordArray[j] == 0)
            {
    
                continue;
            }
            MaxValue = j - RECORDARRAYSIZE;
            TempValue = 0 - MinValue - MaxValue;
            TempIndex = TempValue + RECORDARRAYSIZE;
            if (RecordArray[TempIndex] > 0)
            {
    
                if ((RecordArray[TempIndex] == 1) && (j > TempIndex) && (i < TempIndex))
                {
    
                    Flag = 1;
                }
                else if ((RecordArray[TempIndex] == 2) && (j > TempIndex) && (i <= TempIndex))
                {
    
                    Flag = 1;
                }
                else if ((RecordArray[TempIndex] == 2) && (j >= TempIndex) && (i < TempIndex))
                {
    
                    Flag = 1;
                }
                else if ((RecordArray[TempIndex] > 2) && (j >= TempIndex) && (i <= TempIndex))
                {
    
                    Flag = 1;
                }
                if (Flag)
                {
    
                    (*returnColumnSizes)[*returnSize] = ELEMENTSIZE;
                    ResArray[*returnSize] = (int*)malloc(sizeof(int) * ELEMENTSIZE);
                    ResArray[*returnSize][0] = MinValue;
                    ResArray[*returnSize][2] = MaxValue;
                    ResArray[*returnSize][1] = TempValue;
                    (*returnSize)++;
                    Flag = 0;
                }
            }
        }
    }
    return ResArray;
}

Six、Résultats des opérations