Réponse acceptée !
La solution est ici.
Je n'ai utilisé ni pointeur, ni constructeur, ni destructeur.... c'est basique mais ça fonctionne.
Je crée un tableau de 10 éléments correspondant aux 10 nombres différents possibles.
Je me sers d'une variable TailleUtile qui me permet de faire ensuite le tri uniquement sur les premiers éléments du tableau, dans lesquels j'aurai stocké les nombres différents.
Schématiquement:
tu déclares ton Tableau[0] à Tableau[9]
tu entres tes 10 valeurs au clavier par exemple 2,1,5,5,4,4,4,1,3,8
après chaque saisie, je compare avec les éléments déjà existants dans le tableau, pour voir si ce nombre existe déjà ou non.
s'il n'existe pas, je le mets dans le tableau à l'élément suivant et j'augmente TailleUtile de 1.
à la fin en mémoire il y a ceci
Tableau[0] = 2
Tableau[1]=1
Tableau[2]=5
Tableau[3]=4
Tableau[4]=3
Tableau[5]=8
et les éléments Tableau[6] à Tableau[9] ??? On s'en fout lol... on ne s'en préoccupe plus car grâce à notre variable TailleUtile
on sait maintenant qu'il ne faudra travailler (pour le tri) que sur les 6 premiers éléments de notre tableau!
Le source:
#include <iostream>
using namespace std ; // permet d'éviter la lourdeur de std::cout et std::cin, remplacés par cout et cin
int main ()
{
const unsigned short int TAILLE=10; // taille totale du tableau, correspond aux 10 nombres à entrer au maximum
unsigned short int Tableau[TAILLE];
unsigned short int TailleUtile = 0 ; // permettra de comptabiliser combien il y a effectivement et réellement
// de nombres différents dans ce tableau
bool NombreEstIdentique = false; // servira pour des tests de comparaison avec les nombres déjà existants
// indiquer que la médiane sera calculée à partir de ... nombres à saisir au clavier
cout<<"Entrez " <<TAILLE <<" nombres" <<endl ;
//*********************************************************************************************************************
// l'utilisateur entre successivement les dix nombres, qui sont mis à tour de rôle dans le tableau
// si et uniquement si un nombre identique n'existe pas déjà dans le tableau.
// Si le nombre n'existe pas déjà, on incrémente aussi TailleUtile
// ce qui permettra de faire plus tard un tri parmi les éléments du tableau qui nous intéressent.
unsigned short int ValeurSaisie ;
for (int Iteration=0; Iteration<TAILLE ;Iteration++) // saisie successive de 10 nombres
{
cin >> ValeurSaisie ;
if (Iteration==0) // aucun intérêt de tester la premiere valeur saisie, elle est forcément unique
{
Tableau[0]=ValeurSaisie ; // stocke la valeur saisie au clavier, dans Tableau[0]
TailleUtile ++ ; // on a 1 élément utile dans le tableau
}
else // pour les valeurs suivantes saisies, c'est ici qu'on compare
{
NombreEstIdentique = false ;
for (int Iteration2=0 ; Iteration2<TailleUtile ; Iteration2++) // teste tous les nombres existants déjà
{
if ( ValeurSaisie == Tableau[Iteration2] ) // et compare les successivement à la valeur saisie
NombreEstIdentique = true ;
}
if (NombreEstIdentique == false) // si la valeur saisie n'est pas un nombre existant déjà
{
Tableau[TailleUtile]=ValeurSaisie ; // stocke la valeur saisie , dans Tableau[1] ou Tableau[2...]
TailleUtile++ ; // et on a un nouvel élément utile dans le tableau
}
}
}
//**************************************************************************************************
//affiche le résultat des comparaisons qui viennent d'être effectuées.
cout <<"sont retenus les nombres suivants:" << endl ;
for (int Iteration=0 ; Iteration<TailleUtile ; Iteration++)
{
cout << Tableau[Iteration] <<" " ;
}
cout <<endl;
cout <<"il y a "<< TailleUtile <<" nombres differents parmi les " << TAILLE << " nombres saisis" ;
cout << endl <<endl;
//**************************************************************************************************
// on va maintenant trier par ordre croissant les premiers éléments du tableau
// qui sont tous des nombres différents les uns des autres.
// on sait grâce à la variable TailleUtile éléments, sur combien d'éléments se fera le tri.
unsigned short int Element_A_Comparer=1 ;
unsigned short int swap=0 ; // sera utile pour échanger deux variables
//prendre successivement pour référence l'élément 0 puis 1 puis 2 puis 3.... jusqu'à (TailleUtile-1)
for (unsigned short int Element_De_Reference=0; Element_De_Reference< TailleUtile-1 ; Element_De_Reference ++)
{
while (Element_A_Comparer < (TailleUtile)) // Compare successivement cet élément de référence
// avec tous les éléments suivants du tableau (1 puis 2 puis 3 puis 4 ...)
{
if ( Tableau[Element_A_Comparer] < Tableau[Element_De_Reference] ) // Si un élément suivant
// est plus petit que l'élément de référence
{
//echange les deux valeurs
swap = Tableau[Element_De_Reference] ;
Tableau[Element_De_Reference] = Tableau [Element_A_Comparer];
Tableau[Element_A_Comparer] = swap ;
}
else // sinon teste l'élément suivant
{
Element_A_Comparer ++ ;
}
}
Element_A_Comparer = Element_De_Reference + 1 ; // et compare le uniquement avec les éléments qui le suivent
}
//*************************************************************************************************
// affiche le résultat du tri qui vient d'être réalisé
cout << "voici la suite en ordre croissant: " ;
for (int Iteration=0; Iteration<TailleUtile ;Iteration++)
{
cout << Tableau[Iteration] << " ";
}
cout << endl <<endl;
//*************************************************************************************************
// il est très simple maintenant de trouver la médiane des nombres différents
// ou l'intervalle médian des nombres differents.
if (TailleUtile%2 == 0) // si la taille de la suite est en nombre pair (car la division par 2 n'a pas de reste)
{
cout << "les valeurs differentes sont en nombre pair" << endl <<endl ;
cout << "intervalle median de la suite de nombres differents est" << endl ;
cout << "compris entre: "<< Tableau[(TailleUtile/2)-1] <<" et " << Tableau[TailleUtile/2] << endl;
}
else // sinon c'est que la suite est impaire
{
cout <<"les valeurs differentes sont en nombre impair" << endl << endl;
cout << "la mediane des nombres differents vaut: "<< Tableau[TailleUtile/2] ;
}
cout << endl ;
return 0;
}