C++ Array Tri moi

Question

Collé sur un trieur matriciel. Avoir à trier les chiffres du plus grand au plus petit. J'essaye deux boucles (l'une imbriquée dans l'autre). Voici le code:

int counter=0; // inner counter 
int counter2=0; // outer counter 
int sparky[14]; //array set to 14 just to simplify things 
int holder; // holds the highest value 
int high; //stores the position where it found the value holder 

while (counter2 < howmany) 
{ 
    holder= sparky[counter]; 
    while (counter <= howmany) 
    { 
    counter++; 
    if (sparky[counter] > holder) 
    { 
     holder= sparky[counter]; 
     high= counter; 
    } 
    } 
    counter2++; 
    counter=counter2; 
    sparky[high]= sparky[counter-1]; 
    sparky[counter-1]=holder; 
} 

---

MATRICE UNSORTED:

data[ 0] = 9 
data[ 1] = 8 
data[ 2] = 7 
data[ 3] = 15 
data[ 4] = 14 
data[ 5] = 3 
data[ 6] = 2 
data[ 7] = 1 
data[ 8] = 10 
data[ 9] = 6 
data[10] = 5 
data[11] = 4 
data[12] = 13 
data[13] = 12 
data[14] = 11 

---

MATRICE CLASSÉS EN RAISON DE CODE:

data[ 0] = 15 
data[ 1] = 14 
data[ 2] = 13 
data[ 3] = 12 
data[ 4] = 11 
data[ 5] = 11 
data[ 6] = 10 
data[ 7] = 9 
data[ 8] = 8 
data[ 9] = 7 
data[10] = 6 
data[11] = 5 
data[12] = 4 
data[13] = 3 
data[14] = 2 

Comme vous pouvez le voir le 11 apparaît deux fois dans la code "trié". Même si je tape ceci, je me demande si la valeur de "high" a quelque chose à voir avec ça.

Answer 1

moins que ce soit les devoirs que vous pouvez essayer:

std::sort(A, A + N, std::greater<int>()); 

Answer 2

Pour commencer:

int sparky[14]; 

vous donnera un tableau de 14 éléments sparky[0..13], pas 15 éléments que vous semblez penser .

Deuxièmement, votre boucle interne n'est pas tout à fait correcte. Bien à vous à partir de l'index 1 et passer par à l'index 15 alors, parce tableau C sont basés sur zéro, vous devez être à vélo de 0 jusqu'à 14.

Vous pouvez corriger cela en modifiant la condition de la boucle à while (counter < howmany) et en déplaçant le counter++ juste avant la fin de la boucle interne.

Juste pour préciser ce point, vous faites réellement commencer la boucle à 0 mais, parce que la première chose que vous faites dans la boucle est counter++ avant d'utiliser sparky[counter], vous traitez les éléments à partir de l'index 1. Et, dans la dernière exécution de la boucle, où counter == howmany (14 selon vos autres commentaires ici), vous l'incrémentez à 15 et utilisez cela, ce qui est au-delà de la fin du tableau.

Et, juste pour préciser que des éclaircissements :-), votre boucle est correcte si vous avez howmany réglé sur 14 (soit un inférieur au nombre d'éléments du tableau) puisque, comme vous le soulignez dans un commentaire ailleurs , vous chargez l'élément zéro avant d'entrer dans la boucle interne. Je pense que vous devez toujours définir high chaque fois que vous définissez holder cependant. Si ce n'est pas fait, je reçois deux 6 et deux 2 dans ma liste et pas 3 ou 4.

En guise de remarque secondaire à votre commentaire que howmany est mis à 14, je suggère que les noms de variables doivent faire écho à leur intention. Vous avez clairement 15 éléments dans le tableau (index 0 à 14 inclus). Ne prenez pas cela comme une critique, j'essaie juste de vous aider.

En troisième lieu, (enfin, je crois), vous n'êtes pas mise highchaque fois que vous configurez holder - ceux-ci devraient être en synchronisation pour votre algorithme fonctionne correctement.

S'il vous plaît laissez-nous savoir si ce sont les devoirs. Sinon, je posterai ma solution.Si oui, vous devriez travailler à partir des directives données dans cette réponse et d'autres réponses. Vous devez être conscient que, si ce sont les devoirs et que vous utilisez une solution postée sur un forum public sur Internet (comme celui-ci), vous aurez probablement échoué pour le plagiat. Ne faites pas l'erreur de penser que vos éducateurs ne vérifient pas ce genre de choses.

En bout de ligne, même si je suis heureux d'afficher ma solution, vous ne devriez probablement pas l'utiliser comme un travail de classe. Les meilleures notes pour au moins donner un coup de feu en premier. La plupart des demandeurs d'devoirs semblent venir ici avec rien de plus que les spécifications :-)

Mise à jour: Depuis que vous avez publié ce qui suit:

Désolé pour ne citer que cela fait partie d'un projet de crédit supplémentaire pour un classe.

Je suppose que c'est du travail en classe. Donc, pas de soupe pour vous :-) Pourtant, les trois points ci-dessus devraient suffire pour vous de le réparer. Si vous avez des questions spécifiques à leur sujet, n'hésitez pas à demander dans un commentaire joint à cette réponse.

Bonne chance.

Answer 3

oui il fait ...

regarder où vous utilisez support = Sparky [contre]; et sparky [high] = sparky [counter-1]

Si vous lisez votre code, vous verrez que lorsque la valeur est définie pour la dernière valeur, counter-1 et sparky [high] sont la même chose. cela se produira sur toutes les valeurs, mais vous ne le remarquerez que sur le dernier

essayez d'ajouter un code de débogage pour dire "je déplace cette valeur à cet endroit" pour vous montrer ce que vous faites réellement ... il pourrait aider :)

Answer 4

Essayez ceci:

int counter=0; // inner counter 
int counter2=0; // outer counter 
int sparky[14] = {14,13,12,11,10,9,8,7,6,5,4,3,2,1}; //array set to 14 just to simplify things 
int holder; // holds the highest value 
int FoundIndex; //stores the position where it found the value holder 
int temp; 
bool Found; 
while (counter2 < howmany) 
{ 
    holder= sparky[counter]; 
    Found = false; 
    while (counter <= howmany && !Found) 
    { 

     if (sparky[counter] >= holder) 
     { 
       holder= sparky[counter]; 
       FoundIndex= counter; 
       Found = true; 
     } 
     counter++; 
    } 
    counter2++; 
    counter=counter2; 
    temp = sparky[FoundIndex]; 
    sparky[FoundIndex]= sparky[counter-1]; 
    sparky[counter-1]=temp; 
} 

essentiellement je viens de fixer votre boucle intérieure et d'échange. mais ne l'utilisez pas si vous ne le comprenez pas. Les erreurs que vous avez commises étaient plutôt banales, donc je me sens à l'aise avec l'écriture de code à utiliser ... L'idée de base est, si vous utilisez ce genre de sorte (sans jeu de mots) être très prudent lorsque vos index finissent. Lorsque vous traitez deux compteurs, assurez-vous de les suivre et de leur donner des noms de variables significatifs. counter et counter2 ne sont pas si bons. Essayez quelque chose comme outerCounter et innerCounter. En outre, élevé a été changé en FoundIndex.

rappelez-vous, le code de trace (code qui vient en sortie la valeur d'un varaible) est extrêmement utile pour déterminer ce genre de problème ... juste mettre en « < contre < cout < < endl; a montré qu'il allait sur la fin du tableau ...