Comment trouver le plus grand et le plus petit nombre dans un tableau en c

Question

Je dois trouver un moyen d'afficher le nombre Maximum et Minium dans un tableau, la taille du tableau est 100 et ne dépassera pas cela et il n'y a pas besoin pour la validation d'entrée. Le programme continuera à demander l'entrée jusqu'à ce que 0 soit rencontré et qu'il soit ajouté au tableau.

J'ai tout compris sauf comment garder la trace qui est la plus grande et la plus petite valeur. J'apprécierais que quelqu'un puisse corriger mon code ou me montrer. Un autre problème que j'ai est de terminer la boucle et de faire le calcul max/min dans la boucle while quand l'entrée est égale à 0.

EDIT: J'ai enlevé toutes vos suggestions et édité mon code. Ceci est mon code ci-dessous. Cependant, c'est la sortie n'est pas ce que je m'attends.

#include <stdio.h> 
#include <stdlib.h> 
#define N 100 
int main(void){ 


    int numbers[N]; 
    int i = 0; 
    int j; 
     int input; 
    int maxvalue; 
    int minvalue; 

      printf("Enter the next array element>"); 

scanf("%d", &input); 



while (input != 0){ 

     numbers[i] = input; 
     i++; 

     if (input == 0){ 
        i++; 
      numbers[i] = 0; 
         minvalue = numbers[0]; 
         maxvalue = numbers[0]; 
         for (j=0;j<=i-1;j++){ 

          if (minvalue >= numbers[j]){ 
           minvalue = numbers[j]; 
          }else if (maxvalue <= numbers[j]){ 
           maxvalue = numbers[j]; 
          } 


         } 

/* min = value of first array element 
max = value of first array element 

begin loop for each array element, index = 0 to (n-1) 

--- if array element value is less than min, set min to this value 
--- if array element value is more than max, set max to this value 

increment index and repeat loop til last index is completed 

average = sum/number of elements (n). 
max and min will hold their correct values.*/ 




     } 
       printf("Enter the next array element, while loop>"); 
    scanf("%d", &input); 
    } 


printf("%d\t", maxvalue); 
printf("%d", minvalue); 
    } 

Ceci est la sortie, j'obtiens! Quelqu'un peut-il résoudre cela pour moi?

Enter the next array element>1 
Enter the next array element, while loop>2 
Enter the next array element, while loop>3 
Enter the next array element, while loop>0 
12190144 l6Press [Enter] to close the terminal 

FINAL EDIT: J'ai résolu cela sur mon propre. J'ai mis la vérification min/max en dehors de la boucle WHILE master, cela a permis d'entrer l'entrée de 0 dans le tableau.

#include <stdio.h> 
#include <stdlib.h> 
#define N 100 
int main(void){ 


    int numbers[N]; 
    int i = 0; 
    int j; 
     int input; 
    int maxvalue =1; 
    int minvalue = 1; 
      printf("Enter the next array element>"); 

scanf("%d", &input); 
minvalue = input; 
maxvalue = input; 



while (input != 0){ 
    numbers[i] = input; 

    ++i; 
       printf("Enter the next array element>"); 
    scanf("%d", &input); 

if (input == 0){ 
numbers[i] = 0; 
    ++i; 

    } 

} 
for (j =0;j<i;j++){ 
if (numbers[j] >= maxvalue){ 
           maxvalue = numbers[j]; 
          } 
          if(numbers[j] < minvalue){ 
           minvalue = numbers[j]; 
          } 

} 

printf("%d\t", maxvalue); 
printf("%d\n", minvalue); 

    } 

Answer 1

Tout d'abord, vous affectez input à la valeur de retour de scanf(). C'est le nombre d'éléments assignés par l'appel, et puisque vous dites que l'entrée sera toujours correcte, cette valeur sera toujours 1.

Deuxièmement, vous écrivez après la fin du tableau numbers[] avec la ligne:.

input = scanf("%d", &numbers[100]); 

(vous devriez faire à la place scanf("%d, &input) et affecter numbers[i] à l'entrée dans votre boucle

Enfin, vous n'avez pas besoin de recalculer maxvalue et minvalue en parcourant numbers[] à chaque itération de votre boucle, comparez-les à input et assignez-les en conséquence

J'espère que cela vous met sur la bonne voie.

Answer 2

int cmp(const void *a,const void *b) 
{ 
    return *(const int*)a-*(const int*)b; 
} 
... 
qsort(numbers, 100, sizeof(numbers[0]), cmp); 
printf("\nmin: %d\nmax: %d",numbers[0],numbers[99]); 

Answer 3

Il semble que votre problème central est que vous comparez chaque numéro que contre minvalue. C'est bien pour décider s'il faut remplacer le minvalue actuel, mais évidemment il ne vous dit rien sur la relation de chaque élément à maxvalue.

Un autre problème: il est logique d'initialiser minvalue à partir du premier élément, mais pas si vous le faites dans la boucle. Cela invalide tout votre travail antérieur.

Vous devez également effectuer la même initialisation avec maxvalue. Vous devez initialiser ce nombre à la première valeur.

Vous devez également prendre une décision concernant le calcul du min et du max au fur et à mesure que vous accumulez les données ou lors d'un passage dans les données lorsque vous avez terminé. Ce que vous ne voulez pas faire, cependant, est de passer en revue les éléments passés avec chaque nouveau. Cela donne à votre programme la complexité du temps quadratique sans bénéfice.

Enfin, ne tolérez pas le formatage minable. Déboguer implique toujours d'étudier le code et vous voulez qu'il soit toujours parfaitement formaté à la fois pour être professionnel sur les choses et aussi pour faciliter la lecture de votre propre travail.

Answer 4

Vous posez deux questions, sur la stratégie pour le calcul min/max et pour la boucle. Ne faites pas cela (pour vous) mais résolvez un problème à la fois. Alors d'abord mettre quelque chose comme

signed int input[] = { 8, -5 , /* some more values */ }; 
size_t const n = sizeof input/ sizeof input[0]; 

au début et à oublier vos problèmes scanf. Puis, enveloppez votre détection min/max dans l'instruction de boucle appropriée.

Puis compiler votre code avec des avertissements sur: par exemple -Wall pour gcc, mais cela peut varier pour votre compilateur.

Mine me dit quelque chose:

test numbers.c: 21: avertissement: 'maxvalue' peut être utilisé non initialisée dans ce test-numbers.c fonction : 22: avertissement: ' minvalue » peut être utilisé non initialisée dans cette fonction

cela vous dit que vous faites quelque chose de très mal en ne considérant pas le point de départ de votre algorithme bien.

Answer 5

J'ai reindented votre code et remplacé beaucoup de celui-ci avec `/ * ... PLACEHOLDER ... */

#include <stdio.h> 
#include <stdlib.h> 
#define N 100 
int main(void) { 
    int numbers[N]; 
    int i = 0; 
    int input; 
    int maxvalue; 
    int minvalue; 

    printf("Enter the next array element>"); 
    scanf("%d", &input); 

    while (input != 0) { 
     numbers[i] = input; 
     i++; 

     if (input == 0) { 
      /* ...PLACEHOLDER... */ 
     } 
     printf("Enter the next array element, while loop>"); 
     scanf("%d", &input); 
    } 
    printf("%d\t", maxvalue); 
    printf("%d", minvalue); 
} 

Espérons que vous pouvez voir ce qui se passe lorsque vous entrez 1 ou 2, ou 3 et lorsque vous entrez 0.

Indice: maxvalue et minvalue Les valeurs ne sont jamais modifiées.

Autre indice: combien de fois la ligne while() s'exécute-t-elle?

---

Modifier par exemple exécuter

Pour cette course exemple, le code est sur le côté gauche, ce qui se passe est sur le côté gauche

 
     printf("Enter the next array element>"); | 
     scanf("%d", &input);      | Enter 42 
               | 
     while (input != 0) {      | input is 42, so you do the loop 
      numbers[i] = input;     | numbers[0] = 42 
      i++;         | i = 1 
               | 
      if (input == 0) {     | input != 0; skip placeholder 
       /* ...PLACEHOLDER... */   | 
      }         | 
      printf("Enter the next ...>");  | 
      scanf("%d", &input);     | enter 3 
     }          | 
     while (input != 0) {      | input is 3 
      numbers[i] = input;     | numbers[1] = 3 
      i++;         | i = 2 
               | 
      if (input == 0) {     | input != 0; skip placeholder 
       /* ...PLACEHOLDER... */   | 
      }         | 
      printf("Enter the next ...>");  | 
      scanf("%d", &input);     | enter 0 
     }          | 
     while (input != 0) {      | input is 0, skip while body 
      /* ...PLACEHOLDER... */    | 
     }          | 
     printf("%d\t", maxvalue);    | maxvalue hasn't been initialized 
     printf("%d", minvalue);     | minvalue hasn't been changed