Une fonction qui vérifie combien de fois chaque élément apparaît dans un tableau

Je crée une fonction qui liste un tableau et dit combien de fois chaque élément apparaît.

Ce que j’ai pensé à moi-même jusqu’à présent, c’est que je devrais parcourir en boucle le tableau et qu’il devrait y avoir un compteur pour suivre le nombre de fois qu’il apparaît, puis un deuxième tableau pour placer la valeur de ce compteur en correspondance avec la valeur dans le premier tableau.

Mais je ne peux pas trouver un algorithme pour rechercher si chaque valeur a été répétée à l’intérieur de la boucle.

L’exemple de code a été simplifié et a plus de commentaires

Voici quelques étapes suggérées:
1) en supposant que int a[] soit sortingé (pour faciliter le comptage) (croissant ou décroissant, peu importe).
2) Créez des tableaux distincts pour conserver les résultats trouvés
le premier , num[] stocke la valeur unique, et
second cnt[] stocke le numéro de cette valeur trouvée.
3) boucle à travers un tableau sortingé.
4) en boucle, stocke une valeur unique et le nombre d’occurrences dans le tableau keep.

La routine de sorting qsort() est un concept que vous apprendrez plus tard si vous commencez à vous lancer (ne vous laissez pas distraire pour l’instant), mais observez la partie de cet exemple qui répond à votre question, recherchez le commentaire “Look Here “ . Comme décrit ci-dessus, il parcourt la masortingce et stocke des informations sur le moment où les nombres changent et leur nombre.

Voici un petit exemple de code:

Regardez les commentaires pour savoir où concentrer votre attention sur les compteurs, etc.

 #include  #define sizea 100 //to make variable declarations easier and consistent int num[sizea];//unless array has all unique numbers, will never use this many int cnt[sizea];//same comment int cmpfunc (const void * a, const void * b);//DISREGARD for now (it just works) int main(void) { //a[] is created here as an unsorted array... int a[sizea]={1,3,6,8,3,6,7,4,6,9,0,3,5,12,65,3,76,5,3,54, 1,3,6,89,3,6,7,4,6,9,0,4,5,12,65,3,76,5,3,54, 1,9,6,8,3,45,7,4,6,9,0,89,5,12,65,3,76,5,3,54, 6,3,6,8,3,6,7,4,6,9,0,23,5,12,65,3,76,5,3,54, 1,3,6,90,3,6,7,4,6,9,0,5,5,12,65,3,76,5,3,54}; int i, j, ncount; for(i=0;i 

Pour l'exemple de tableau inclus, voici les résultats utilisant ce code:

entrez la description de l'image ici

Au début, vous devez définir une liste avec les nombres entiers que vous avez et leur nombre d’apparences

 struct linked_list { int value; int numOf; linked_list *next; }; 

alors vous devez avoir les fonctions pour utiliser cette liste, comme créer une liste, y insérer un élément, trouver un nœud dans cette liste et l’imprimer dans la liste.

 linked_list* newItem(int value) { linked_list * temp = (linked_list *)malloc(sizeof(linked_list)); (*temp).value = value; (*temp).numOf = 1; return temp; } linked_list* findItem(linked_list *head, int value) { linked_list *counter = head; while (counter != NULL && (*counter).value != value) { counter = (*counter).next; } return counter; } void pushToList(linked_list **head, linked_list *item) { (*item).next = *head; *head = item; } void printList(linked_list *head) { while (head != NULL) { printf("%d:%d\n", (*head).value, (*head).numOf); head = (*head).next; } } 

Vous devez étudier les listes pour comprendre leur fonctionnement. Ensuite, votre logique de code va comme ceci:

 linked_list *duplicate = NULL; int i; int list[11] = { 1, 2, 3, 4, 1, 2, 3, 4, 0, 1, 2 }; for (i = 0; i < 11; i++) { linked_list *current = findItem(duplicate, list[i]); if (current == NULL) pushToList(&duplicate, newItem(list[i])); else (*current).numOf++; } printList(duplicate); while (1); return 0; 

(Je dois libérer la liste mais je ne l'ai pas dans ce code: P)

Je fais une liste avec les éléments / éléments qui peuvent être dupliqués. Je pars du début du tableau. Je vérifie le premier élément du tableau, puis je vérifie s'il se trouve sur la liste des doublons. Si je ne le trouve pas dans la liste, je crée un nouvel enregistrement dans la liste en double avec 1 nombre de comparutions. Ensuite, je vérifie le rest, s’ils apparaissent dans la liste, j’ajoute le nombre de comparutions d’une unité, s’ils ne le sont pas, je fais un nouvel enregistrement. À la fin, ma liste comportera tous les numéros et leur nombre de comparutions.

Ce code prend O (n) pas si votre différence de données est une constante. Si votre différence de données augmente avec le nombre d'éléments, cela nécessitera davantage d'étapes.

Cette approche est souvent préférable au sorting des algorithmes en termes de nombre d’étapes à exécuter et d’allocation de mémoire.

J’ai posté un pseudo-code, pour vous aider avec l’algorithme que vous avez dit que vous êtes incapable de comprendre. J’espère que cela vous encouragera à commencer le code.

 //store the first number in a variable and find //how many times it occurs in the array, repeat this for all //the elements in the array int current = arr[0]; int i=0, count=0; for(i=0; i < arr.length;i++){ // loop through all the elements of the array if(arr[i]==current) { count++; // if current number is same as the number you are looking for // then increment the counter } // end of if-loop }