public async Task inserer(int valeur, Canvas c, Commentaire comPrincipal, Canvas Alg)
//Insetion d'un nouvel élément dans le tableau //
{
int[] tabInfo = new int[2];
Point[] tab_point = new Point[2];
Commentaire comDecalage = new Commentaire("On décale les valeurs pour l'insertion ", Brushes.Black, this.coordX + 50, this.coordY - 50, 210, 30, Brushes.GreenYellow, Brushes.White);
Algo algo = new Algo(6, coordX_Algo, coordY_Algo);
Algo algo1 = new Algo(27, coordX_Algo, coordY_Algo);
int pos;//Position d'insertion
int i = tailleTab;
comPrincipal.disparaitre(0);
if (i < tailleMaxTab)
{
Case nouvelleCase = new Case(valeur, coordX, this.coordY - 100, 1, heightOfcase, widthOfcase, couleurFondCase, couleurBordureCase, 1);
if (tailleTab > 0) //Si il exite au moins une case
{
await recherche(valeur, tabInfo, c, true, comPrincipal, Alg); //Recherche Dichothomique de la valeur
comPrincipal.disparaitre(0);
}
if (tabInfo[0] == 0) //Si la valeur n'existe pas
{
pos = tabInfo[1];
tabIndices[tailleTab].afficher(c); //Afficher le nouvel indice
nouvelleCase.afficher(c); //Affichage de la nouvelle case crée
if (this.triee)
{
algo.afficher(Alg);
await algo.colorer(couleurAlgo, 0, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 1, Temps.time);
comDecalage.ajouterCanvas(c); //Affichage du message d'insertion
for (i = this.tailleTab; i > pos; i--) //Décalage des cases pour insérer la nouvelle valeur
{
await algo.colorer(couleurAlgo, 2, Temps.time);
tab_point[0] = new Point(coordX + i * widthOfcase, coordY);
tab[i] = tab[i - 1]; //Décalage interne des cases du tableau
tab[i - 1].deplacer(tab_point, 1); //Décalage graphique des cases du tableau
await algo.colorer(couleurAlgo, 3, Temps.time);
await Task.Delay(TimeSpan.FromSeconds(Temps.time));
await algo.colorer(couleurAlgo, 4, Temps.time);
}
await algo.colorer(couleurAlgo, 5, Temps.time);
comDecalage.enleverCanvas(c);
tab_point[0] = new Point(coordX + i * widthOfcase, coordY);
tab[i] = nouvelleCase;
tab[i].deplacer(tab_point, 1);//Insértion graphique de la case
comPrincipal.Width = 200;
comPrincipal.CouleurFond = couleurComPrincipal;
comPrincipal.Text = "Insertion de la valeur ";
comPrincipal.apparaitre(0);
await algo.colorer(couleurAlgo, 6, Temps.time);
comPrincipal.disparaitre(0);
await algo.colorer(couleurAlgo, 7, Temps.time);
await algo.colorer(couleurAlgo, 8, 0.5 *Temps.time);
this.tailleTab++;//Incrémentation de la taille du tableau
algo.disparaitre(Alg);
}
else
{
algo1.afficher(Alg);
tab_point[0] = new Point(coordX + i * widthOfcase, coordY);
tab[i] = nouvelleCase;
tab[i].deplacer(tab_point, 1);//Insértion graphique de la case
comPrincipal.Width = 200;
comPrincipal.CouleurFond = couleurComPrincipal;
comPrincipal.Text = "Insertion de la valeur ";
comPrincipal.apparaitre(0);
comPrincipal.disparaitre(0);
this.tailleTab++;//Incrémentation de la taille du tableau
algo1.disparaitre(Alg);
}
}
else
{
comPrincipal.CouleurFond = couleurComPrincipal;
comPrincipal.Text = "Insertion impossible , la valeur existe déja ";
comPrincipal.Width = 320;
comPrincipal.apparaitre(0);
await Task.Delay(TimeSpan.FromSeconds(Temps.time + 1));
comPrincipal.disparaitre(0);
}
}
else
{
comPrincipal.CouleurFond = couleurComPrincipal;
comPrincipal.Text = "Insertion impossible , taille du tableau maximum atteinte ";
comPrincipal.Width = 320;
comPrincipal.apparaitre(0);
await Task.Delay(TimeSpan.FromSeconds(Temps.time + 1));
comPrincipal.disparaitre(0);
}
}
private async Task rechercheSeq(int val, int[] tabInfo, Canvas c, Boolean insSup, Commentaire comPrincipal, Canvas Alg)
{
//Effectue une recherche séquentiel dans le tableau tab
// tabInfo[0] correspond au boolean trouv et tabInfo[1] correspond à l'indice de la valeur val si il est trouvée sinon l'indice ou devrait être insérée cette valeur .
// inserSup est un boolean qui indique si il ya une insertion ou suppression aprés cette recherche
int i = 0;
tabInfo[0] = 0;
SolidColorBrush couleurparcours = Brushes.Red;
SolidColorBrush couleurtrouve = Brushes.Green;
Commentaire com = new Commentaire(" ", Brushes.Black, this.tab[i].CoordX - 5, this.tab[i].CoordY - 35, 50, 50, couleurparcours, couleurparcours);
Algo algo = new Algo(1, coordX_Algo, coordY_Algo);
algo.afficher(Alg);
com.ajouterCanvas(c);
com.opacity = 0;
com.Height = 30;
com.Width = 160;
await algo.colorer(couleurAlgo, 0, Temps.time);
await algo.colorer(couleurAlgo, 1, Temps.time);
await algo.colorer(couleurAlgo, 2, Temps.time);
while (i < this.tailleTab & tabInfo[0] == 0)
{
await algo.colorer(couleurAlgo, 3, Temps.time);
this.tab[i].Forme.Opacity = 0.7;
this.tabIndices[i].Forme.Opacity = 0.7;
if (this.tab[i].Valeur != val)
{
com.CoordX = this.tab[i].CoordX;
this.tab[i].colorChamp(couleurparcours, Brushes.Black, 1);
this.tabIndices[i].colorChamp(couleurparcours, Brushes.Black, 0);
com.Text = " " + this.tab[i].Valeur + " est différente de " + val;
com.apparaitre(Temps.time);
await Task.Delay(TimeSpan.FromSeconds(Temps.time));
this.tab[i].colorChamp(couleurFondCase, couleurBordureCase, 1);
this.tabIndices[i].colorChamp(couleurFondCase, couleurBordureCase, 0);
await algo.colorer(couleurAlgo, 6, Temps.time);
i++;
}
else
{
tabInfo[0] = 1;
comPrincipal.disparaitre(1);
comPrincipal.Text = "La valeur " + val + " a été trouvé";
await algo.colorer(couleurAlgo, 4, Temps.time);
comPrincipal.CouleurFond = couleurtrouve;
this.tab[i].Forme.Opacity = 0.7;
comPrincipal.apparaitre(Temps.time);
this.tabIndices[i].Forme.Opacity = 0.7;
if (insSup == false)
{
this.tab[i].colorChamp(couleurtrouve, couleurtrouve, 1);
this.tabIndices[i].colorChamp(couleurtrouve, couleurtrouve, 0);
await algo.colorer(couleurAlgo, 5, Temps.time);
com.disparaitre(0);
// this.tab[i].vibrate(4, 19);
await Task.Delay(TimeSpan.FromSeconds(4));
}
else
{
this.tab[i].colorChamp(couleurtrouve, couleurtrouve, 1);
this.tabIndices[i].colorChamp(couleurtrouve, couleurtrouve, 0);
await algo.colorer(couleurAlgo, 5, Temps.time);
com.disparaitre(0);
}
tabInfo[1] = i;
}
}
if (tabInfo[0] == 0)
{
comPrincipal.disparaitre(2.5);
comPrincipal.Width = 200;
comPrincipal.Text = "La valeur " + val + " n'a pas été trouvé";
comPrincipal.CouleurFond = couleurparcours;
comPrincipal.apparaitre(Temps.time);
com.disparaitre(0.5);
com.enleverCanvas(c);
i--;
}
await Task.Delay(TimeSpan.FromSeconds(1.5));
for (i = 0; i < this.tailleTab; i++)
{
this.tab[i].colorChamp(couleurFondCase, couleurBordureCase, 1);
this.tab[i].Forme.Opacity = 1;
this.tabIndices[i].colorChamp(Brushes.Transparent, Brushes.Transparent, 0);
this.tab[i].TextBLock.Foreground = Brushes.Black;
}
comPrincipal.disparaitre(0.5);
com.enleverCanvas(c);
await algo.colorer(Brushes.Red, 7, 0.5 *Temps.time);
algo.disparaitre(Alg);
}
public async Task suppression(int valeur, Canvas c, Commentaire comPrincipal, Canvas Alg)
{
int[] tabInfo = new int[2]; //Le tableau qui sera modifié par la fonction de recherche
await recherche(valeur, tabInfo, c, true, comPrincipal, Alg); //Il retourne un entier qui décrit l'echec (0) ou la réussite (1) de la recherche ainsi que la position
comPrincipal = new Commentaire("Suppression en cours ...", Brushes.Black, this.coordX, this.coordY - 150, 150, 70, Brushes.PaleGreen, Brushes.White);
Algo algo = new Algo(7, coordX_Algo, coordY_Algo);
if (tabInfo[0] == 1)
{
Commentaire com = new Commentaire("On décrémente la taille du tableau", Brushes.Black, this.coordX + this.tab[tabInfo[1]].Width * tabInfo[1], this.coordY - tab[0].Height, 200, 30, Brushes.GreenYellow, Brushes.White);
com.ajouterCanvas(c); //On crée le commentaire qui explique l'avacncement de l'algorithme
Point[] tabl = new Point[3];
if (this.triee && (tabInfo[1] < tailleTab - 1)) //Cas trié, on traitera le cas où la valeur recherchée se trouve à la fin du tableau à part
{
algo.afficher(Alg);
await algo.colorer(couleurAlgo, 0, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 1, Temps.time);
com.Text = "On décale toutes les cases suivantes";
com.Width = 200;
com.Height += 20;
com.apparaitre(0); //On adapte le commentaire au contexte
tabl[0] = new Point(tabInfo[1] * widthOfcase + coordX, coordY); //On fait disparaître la case à supprimer
this.tab[tabInfo[1]].disappear(tabl, 1);
int i;
for (i = tabInfo[1]; i < this.tailleTab - 1; i++) //On effectue les décalages
{
await algo.colorer(couleurAlgo, 2, Temps.time);
tabl[0] = new Point(i * widthOfcase + coordX, coordY);
this.tab[i + 1].deplacer(tabl, 1);
await algo.colorer(couleurAlgo, 3, Temps.time);
await Task.Delay(TimeSpan.FromSeconds(Champ.time));
this.tab[i] = this.tab[i + 1];
await algo.colorer(couleurAlgo, 4, Temps.time);
}
await algo.colorer(couleurAlgo, 5, Temps.time);
await algo.colorer(couleurAlgo, 6, Temps.time);
await algo.colorer(couleurAlgo, 7, 0.5 *Temps.time);
algo.disparaitre(Alg);
}
else if (tabInfo[1] != tailleTab - 1) //Cas non trié, supression d'un élément au milieu
{
com.Text = "On remplace le contenu de la case\npar celui de la dernière case\net on décrémente la taille";
com.Width = 200;
com.Height = 70;
com.CoordX = com.CoordX - this.tab[0].Width;
com.CoordY -= 30;
com.apparaitre(0); //On adapte le commentaire et on l'affiche
tabl[0] = new Point(tabInfo[1] * widthOfcase + coordX, coordY); //La case à supprimer disparaît sur place
this.tab[tabInfo[1]].disappear(tabl, 1);
this.tab[tabInfo[1]] = this.tab[this.tailleTab - 1]; //On reemplcae la première valeur par la dernière
tabl[0] = new Point((tailleTab - 1) * widthOfcase + coordX, coordY - heightOfcase);
tabl[1] = new Point(tabInfo[1] * widthOfcase + coordX, coordY - heightOfcase);
tabl[2] = new Point(tabInfo[1] * widthOfcase + coordX, coordY); //On définit les points par où passe la case à déplacer
this.tab[tailleTab - 1].deplacer(tabl, 3); //Animation du remplacement
await Task.Delay(TimeSpan.FromSeconds(Champ.time));
com.disparaitre(Champ.time);
}
else //Cas non trié, suppression d'un élément à la fin
{
tabl[0] = new Point(tabInfo[1] * widthOfcase + coordX, coordY); //Gestion de l'animation (disparition de la dernière case)
this.tab[tabInfo[1]].disappear(tabl, 1);
}
this.tailleTab--; //On décrémente la taille
this.tabIndices[tailleTab].masquer(c); //On masque Le dernier indice
await Task.Delay(TimeSpan.FromSeconds(Temps.time));
com.enleverCanvas(c); //Fin de l'animation
comPrincipal.CouleurFond = Brushes.Green; //Commentaire de réussite de la suppression
comPrincipal.Text = "Suppression réussie";
comPrincipal.apparaitre(0);
await Task.Delay(TimeSpan.FromSeconds(Temps.time));
}
else //Cas de non suppression (élément non trouvé)
{
comPrincipal.CouleurFond = Brushes.Red; //Commentaire d'échec de suppression
comPrincipal.Text = "Suppression impossible\nélément non trouvé";
comPrincipal.apparaitre(0);
await Task.Delay(TimeSpan.FromSeconds(Temps.time));
}
}
private async Task rechercheDicho(int val, int[] tabInfo, Canvas c, Boolean inserSupp, Commentaire comPrincipal, Canvas Alg)
//Effectue une recherche dichotomique dans le tableau tab
// tabInfo[0] correspond au boolean trouv et tabInfo[1] correspond à l'indice de la valeur val si il est trouvée sinon l'indice ou devrait être insérée cette valeur .
// inserSup est un boolean qui indique si il ya une insertion ou suppression aprés cette recherche
{
SolidColorBrush couleurBorneSup = Brushes.Red;
SolidColorBrush couleurBorneInf = Brushes.Blue;
SolidColorBrush couleurDeCaseMed = Brushes.SeaGreen;
SolidColorBrush couleurTrouv = Brushes.Green;
Algo algo = new Algo(2, coordX_Algo, coordY_Algo);
algo.afficher(Alg);
int bSup = this.tailleTab - 1, bInf = 0, med = 0, i, e = -5, d = -55;
Point[] tabDepBSup = new Point[1], tabDepBInf = new Point[1], tabDepMedCase = new Point[1], tabDepBSupInd = new Point[1], tabDepBInfInd = new Point[1], tabDepMedCaseInd = new Point[1];
await algo.colorer(couleurAlgo, 0, Temps.time);
await algo.colorer(couleurAlgo, 1, Temps.time);
await algo.colorer(couleurAlgo, 2, Temps.time);
tabDepBSup[0] = new Point();
tabDepBSup[0].Y = this.coordY;
tabDepBInf[0] = new Point();
tabDepBInf[0].Y = this.coordY;
tabDepMedCase[0] = new Point();
tabDepMedCase[0].Y = this.coordY;
tabDepBSupInd[0] = new Point();
tabDepBSupInd[0].Y = this.coordY + b;
tabDepBInfInd[0] = new Point();
tabDepBInfInd[0].Y = this.coordY + b;
tabDepMedCaseInd[0] = new Point();
tabDepMedCaseInd[0].Y = this.coordY + b;
Boolean firstIteration = true;
Champ borneSup = new Champ(this.coordX + widthOfcase * bSup, this.coordY, 1, heightOfcase, widthOfcase, Brushes.Transparent, couleurBorneSup, 6);
Champ borneInf = new Champ(this.coordX + widthOfcase * bInf, this.coordY, 1, heightOfcase, widthOfcase, Brushes.Transparent, couleurBorneInf, 6);
Champ medCase = new Champ();
Champ borneSupInd = new Champ(this.coordX + widthOfcase * bSup + a, this.coordY + b, 2, 25, 25, couleurBorneSup, couleurBorneSup, 1);
Champ borneInfInd = new Champ(this.coordX + widthOfcase * bInf + a, this.coordY + b, 2, 25, 25, couleurBorneInf, couleurBorneInf, 1);
Champ medCaseInd = new Champ();
borneSup.Forme.Opacity = 0.7;
borneInf.Forme.Opacity = 0.7;
borneSupInd.Forme.Opacity = 0.5;
borneInfInd.Forme.Opacity = 0.5;
borneSup.afficher(c);
borneInf.afficher(c);
borneSupInd.afficher(c);
borneInfInd.afficher(c);
tabInfo[0] = 0;
Commentaire comBorneSup = new Commentaire("On positionne la borne supérieure \nà la positon du milieu -1 ", Brushes.Black, tab[bSup].CoordX + e, tab[bSup].CoordY + d, 188, 50, couleurBorneSup, couleurBorneSup);
Commentaire comBorneInf = new Commentaire("On positionne la borne inférieure \nà la positon du milieu +1 ", Brushes.Black, tab[bInf].CoordX + e, tab[bInf].CoordY + d, 188, 50, couleurBorneInf, couleurBorneInf);
Commentaire comMed = new Commentaire("", Brushes.Black, tab[med].CoordX + e, tab[med].CoordY + d, 50, 50, couleurDeCaseMed, couleurDeCaseMed);
comBorneSup.opacity = 0;
comBorneInf.opacity = 0;
comBorneSup.ajouterCanvas(c);
comBorneInf.ajouterCanvas(c);
while ((bInf <= bSup) && (tabInfo[0] == 0))
{
await algo.colorer(couleurAlgo, 3, Temps.time);
med = (bSup + bInf) / 2;
comMed.Text = "On positionne le \nmilieu du tableau";
comMed.Height = 50;
comMed.Width = 100;
comMed.CoordX = this.tab[med].CoordX + e;
comMed.CoordY = this.tab[med].CoordY + d;
if (firstIteration)
{
medCase = new Champ(this.coordX + widthOfcase * med, this.coordY, 1, heightOfcase, widthOfcase, Brushes.Transparent, couleurDeCaseMed, 6);
medCaseInd = new Champ(this.coordX + widthOfcase * med + a, this.coordY + b, 2, 25, 25, couleurDeCaseMed, couleurDeCaseMed, 1);
medCase.Forme.Opacity = 0.7;
medCaseInd.Forme.Opacity = 0.5;
medCase.afficher(c);
medCaseInd.afficher(c);
firstIteration = false;
comMed.ajouterCanvas(c);
await algo.colorer(couleurAlgo, 4, Champ.time);
comMed.disparaitre(Champ.time);
await Task.Delay(TimeSpan.FromSeconds(Champ.time + 1));
}
else
{
tabDepBSup[0].X = this.coordX + widthOfcase * bSup;
tabDepBInf[0].X = this.coordX + widthOfcase * bInf;
tabDepMedCase[0].X = this.coordX + widthOfcase * med;
tabDepBSupInd[0].X = this.coordX + widthOfcase * bSup + a;
tabDepBInfInd[0].X = this.coordX + widthOfcase * bInf + a;
tabDepMedCaseInd[0].X = this.coordX + widthOfcase * med + a;
borneSup.deplacer(tabDepBSup, 1);
borneInf.deplacer(tabDepBInf, 1);
borneSupInd.deplacer(tabDepBSupInd, 1);
borneInfInd.deplacer(tabDepBInfInd, 1);
await Task.Delay(TimeSpan.FromSeconds(Champ.time + 1));
medCase.deplacer(tabDepMedCase, 1);
medCaseInd.deplacer(tabDepMedCaseInd, 1);
comMed.apparaitre(Champ.time);
await algo.colorer(couleurAlgo, 4, 2 *Temps.time);
comMed.disparaitre(Champ.time);
await Task.Delay(TimeSpan.FromSeconds(Champ.time + 1));
if (bSup != this.tailleTab)
{
for (i = bSup + 1; i < this.tailleTab; i++)
{
tab[i].colorChamp(Brushes.Gray, couleurBordureCase, 1);
tab[i].Forme.Opacity = 0.2;
tab[i].TextBLock.Foreground = Brushes.Gray;
}
}
if (bInf != 0)
{
for (i = bInf - 1; i > -1; i--)
{
tab[i].colorChamp(Brushes.Gray, couleurBordureCase, 1);
tab[i].Forme.Opacity = 0.2;
tab[i].TextBLock.Foreground = Brushes.Gray;
}
}
await Task.Delay(TimeSpan.FromSeconds(Temps.time));
}
if (tab[med].Valeur == val)
{
tabInfo[0] = 1;
}
else
{
await algo.colorer(couleurAlgo, 6, Temps.time);
if (tab[med].Valeur > val)
{
comMed.Text = val + " est inférieure à la \nvaleur du milieu du tableau";
comMed.Height = 50;
comMed.Width = 152;
comMed.apparaitre(Temps.time);
await algo.colorer(couleurAlgo, 9, 2 *Temps.time + 3);
await Task.Delay(TimeSpan.FromSeconds(Temps.time + 1.5));
comMed.disparaitre(Temps.time);
await Task.Delay(TimeSpan.FromSeconds(Temps.time + 1.5));
comBorneSup.CoordX = this.tab[bSup].CoordX + e;
comBorneSup.apparaitre(Temps.time);
await algo.colorer(couleurAlgo, 10, 2 *Temps.time);
comBorneSup.disparaitre(Temps.time);
await Task.Delay(TimeSpan.FromSeconds(Temps.time + 2));
bSup = med - 1;
}
else
{
comMed.Text = val + " est supérieure à la \nvaleur du milieu du tableau";
comMed.Height = 50;
comMed.Width = 152;
comMed.apparaitre(Temps.time);
await algo.colorer(couleurAlgo, 7, 2 *Temps.time);
comMed.disparaitre(Temps.time);
await Task.Delay(TimeSpan.FromSeconds(Temps.time + 1));
comBorneInf.CoordX = this.tab[bInf].CoordX + e;
comBorneInf.apparaitre(Temps.time);
await algo.colorer(couleurAlgo, 8, 2 *Temps.time);
comBorneInf.disparaitre(Temps.time);
await Task.Delay(TimeSpan.FromSeconds(Temps.time + 2));
bInf = med + 1;
}
}
}
if (tabInfo[0] == 0)
{
tabDepBSup[0].X = this.coordX + widthOfcase * bSup;
tabDepBInf[0].X = this.coordX + widthOfcase * bInf;
tabDepBSupInd[0].X = this.coordX + widthOfcase * bSup + a;
tabDepBInfInd[0].X = this.coordX + widthOfcase * bInf + a;
borneSup.deplacer(tabDepBSup, 1);
borneInf.deplacer(tabDepBInf, 1);
borneSupInd.deplacer(tabDepBSupInd, 1);
borneInfInd.deplacer(tabDepBInfInd, 1);
await Task.Delay(TimeSpan.FromSeconds(Temps.time));
if (bSup != this.tailleTab)
{
for (i = bSup + 1; i < this.tailleTab; i++)
{
tab[i].colorChamp(Brushes.Gray, couleurBordureCase, 1);
tab[i].Forme.Opacity = 0.2;
tab[i].TextBLock.Foreground = Brushes.Gray;
}
}
if (bInf != 0)
{
for (i = bInf - 1; i > -1; i--)
{
tab[i].colorChamp(Brushes.Gray, couleurBordureCase, 1);
tab[i].Forme.Opacity = 0.2;
tab[i].TextBLock.Foreground = Brushes.Gray;
}
}
await Task.Delay(TimeSpan.FromSeconds(0.5));
tabInfo[1] = bInf;
comPrincipal.disparaitre(Temps.time);
await Task.Delay(TimeSpan.FromSeconds(Temps.time));
comPrincipal.Width = 350;
comPrincipal.Height = 50;
comPrincipal.CouleurFond = Brushes.Red;
comPrincipal.Text = "Condition d'arrêt : Borne supérieure < Borne inférieure";
comPrincipal.apparaitre(Temps.time);
}
else
{
await Task.Delay(TimeSpan.FromSeconds(Temps.time));
await algo.colorer(couleurAlgo, 5, 2 *Temps.time);
tabInfo[1] = med;
for (i = 0; i < this.tailleTab; i++)
{
this.tab[i].colorChamp(couleurFondCase, couleurBordureCase, 1);
this.tab[i].Forme.Opacity = 1;
this.tab[i].TextBLock.Foreground = Brushes.Black;
}
c.Children.Remove(borneSup.Forme);
c.Children.Remove(borneInf.Forme);
c.Children.Remove(medCase.Forme);
c.Children.Remove(borneSupInd.Forme);
c.Children.Remove(borneInfInd.Forme);
c.Children.Remove(medCaseInd.Forme);
comPrincipal.disparaitre(Temps.time);
await Task.Delay(TimeSpan.FromSeconds(Temps.time));
comPrincipal.CouleurFond = couleurTrouv;
await Task.Delay(TimeSpan.FromSeconds(0.5));
comPrincipal.Text = "Valeur " + val + " a été trouvée";
if (inserSupp)
{
this.tab[med].colorChamp(couleurTrouv, couleurTrouv, 1);
this.tab[med].Forme.Opacity = 0.7;
}
else
{
this.tab[med].colorChamp(couleurTrouv, couleurTrouv, 1);
this.tab[med].Forme.Opacity = 0.7;
// this.tab[med].vibrate(2, 19);
}
comPrincipal.apparaitre(Temps.time);
}
await Task.Delay(TimeSpan.FromSeconds(3));
for (i = 0; i < this.tailleTab; i++)
{
this.tab[i].colorChamp(couleurFondCase, couleurBordureCase, 1);
this.tab[i].Forme.Opacity = 1;
this.tab[i].TextBLock.Foreground = Brushes.Black;
}
comPrincipal.disparaitre(0.5);
c.Children.Remove(borneSup.Forme);
c.Children.Remove(borneInf.Forme);
c.Children.Remove(medCase.Forme);
c.Children.Remove(borneSupInd.Forme);
c.Children.Remove(borneInfInd.Forme);
c.Children.Remove(medCaseInd.Forme);
comBorneInf.enleverCanvas(c);
comBorneSup.enleverCanvas(c);
comMed.enleverCanvas(c);
await algo.colorer(couleurAlgo, 11, Temps.time);
algo.disparaitre(Alg);
}
public async Task recherche_seq(int val, int[] tabInfo, Canvas c, Boolean insSup, Commentaire comPrincipal, Canvas Algo)
{
//recherche de la valeur val et returne indice qui se trouve dans tabInfo
int i = 0;
tabInfo[0] = 0;
Algo algo = new Algo(15, coordX_Algo, coordY_Algo); //Création d'un algorithme de déroulement
SolidColorBrush couleurparcours = Brushes.Red;
SolidColorBrush couleurtrouve = Brushes.Green;
Commentaire com = new Commentaire(" ", Brushes.Black, this.coordX - 5, this.coordY - 35, 50, 50, couleurparcours, couleurparcours);
comPrincipal.CouleurFond = Brushes.Yellow;
comPrincipal.CouleurBordure = Brushes.Black;
comPrincipal.apparaitre(1); //Apparaitre le commentaire principale
comPrincipal.Text = "Recherche en cours ...";
algo.afficher(Algo); //Affichage de l'algorithme
await algo.colorer(couleurAlgo, 0, 0.5 *Temps.time); //Déroulement de l'algorithme
await algo.colorer(couleurAlgo, 1, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 2, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 3, 0.5 *Temps.time);
com.ajouterCanvas(c);
com.disparaitre(0);
com.opacity = 0;
com.Height = 30;
com.Width = 160;
Fleche parcours = new Fleche(1);//Création de la fléche de parcourt
parcours.Height = tailleFleche;
parcours.StrokeThick = 3;
parcours.Color = couleurparcours;
parcours.L.Opacity = 0.9;
parcours.CoordY = this.coordY + widthOfmaillon / 2;
if (this.triee == false) //Si la liste n'est pas triée
{
while (i < this.list.Count && tabInfo[0] == 0) //Si on est pas arriver à la fin de la liste
{
await algo.colorer(couleurAlgo, 4, 0.5 *Temps.time);
this.list[i].opacity = 0.7;
if (this.list[i].Valeur != val)//Si la valeur du maillon est différente de la valeur rechercher
{
com.CoordX = this.list[i].CoordX;
com.CoordY = this.list[i].CoordY - 35;
this.list[i].colorMaillon(couleurparcours, couleurBordureMaillon, 2);//On colorie en gris le maillon
this.list[i].colorCase(couleurparcours, couleurBordureMaillon, 2);
com.Text = " " + this.list[i].Valeur + " est différent de " + val;
com.apparaitre(Temps.time);//On affiche le commantaire que la valeur du maillon est différente de la valeur rechercher
await algo.colorer(couleurAlgo, 7, 0.5 *Temps.time);
parcours.CoordX = list[i].Adr.CoordX;//On passe au coordonnée de la fléche du maillon suivant
parcours.bout = new Bout(list[i].Adr.bout.coordX, list[i].Adr.bout.coordY, couleurparcours, list[i].Adr.bout.TypeBout, 2.5);
if (i < list.Count - 1)
{
await parcours.dessiner(Temps.time, c); //On dessine la fléche du partcourt
}
await algo.colorer(couleurAlgo, 8, Temps.time);
parcours.retirerCanvas(c);
com.disparaitre(0);
this.list[i].colorMaillon(couleurFondMaillon, couleurBordureMaillon, 2); tabInfo[1] = tabInfo[1] + 1;
this.list[i].colorCase(couleurFondMaillon, couleurBordureMaillon, 2);
await algo.colorer(couleurAlgo, 9, Temps.time);
}
else//Si on a trouver la valeur
{
await algo.colorer(couleurAlgo, 5, Temps.time);
tabInfo[0] = 1;//Indiquer qu'on a trouvé la valeur
comPrincipal.disparaitre(1);
comPrincipal.Text = "La valeur " + val + " a été trouvée";
comPrincipal.CouleurFond = couleurtrouve;
comPrincipal.CouleurBordure = couleurtrouve;
this.list[i].opacity = 0.7;
comPrincipal.apparaitre(Temps.time);
await algo.colorer(couleurAlgo, 6, Temps.time);
if (insSup == false)//Si il n'y a pas d'insertion aprés
{
this.list[i].colorMaillon(couleurtrouve, couleurtrouve, 2);
this.list[i].colorCase(couleurtrouve, couleurtrouve, 2);
com.disparaitre(0);
this.list[i].clignoter(couleurtrouve, couleurtrouve, 2, 3);
await Task.Delay(TimeSpan.FromSeconds(4));
}
else
{
this.list[i].colorMaillon(couleurtrouve, couleurtrouve, 2);
this.list[i].colorCase(couleurtrouve, couleurtrouve, 2);
com.disparaitre(0);
}
await algo.colorer(couleurAlgo, 9, 0.5 *Temps.time);
}
await algo.colorer(couleurAlgo, 10, 0.2 *Temps.time);
i++;
}
await algo.colorer(couleurAlgo, 11, 0.2 *Temps.time);
}
else//Si la liste est triée
{
parcours.CoordX = heightOfmaillon + list[i].CoordX;
while (i < this.list.Count && tabInfo[0] == 0 && list[i].Valeur <= val)//On s'arrete si on arrive à nil ou si on trouve une valeur supérieur à la valeur rechercher
{
await algo.colorer(couleurAlgo, 4, 0.5 *Temps.time);
this.list[i].opacity = 0.7;
if (this.list[i].Valeur != val)
{
com.CoordX = this.list[i].CoordX;
com.CoordY = this.list[i].CoordY - 35;
this.list[i].colorMaillon(couleurparcours, couleurBordureMaillon, 2);
this.list[i].colorCase(couleurparcours, couleurBordureMaillon, 2);
com.Text = " " + this.list[i].Valeur + " est différent de " + val;
com.apparaitre(Temps.time);//faire apparaitre le commentaire
await algo.colorer(couleurAlgo, 7, 0.5 *Temps.time);
parcours.CoordX = list[i].Adr.CoordX;
parcours.bout = new Bout(list[i].Adr.bout.coordX, list[i].Adr.bout.coordY, couleurparcours, list[i].Adr.bout.TypeBout, 2.5);
if (i < list.Count - 1)
{
await parcours.dessiner(Temps.time, c);
}
await algo.colorer(couleurAlgo, 8, Temps.time);
com.disparaitre(0);//faire disparaitre le commentaire
parcours.retirerCanvas(c);
this.list[i].colorMaillon(couleurFondMaillon, couleurBordureMaillon, 2); tabInfo[1] = tabInfo[1] + 1;
this.list[i].colorCase(couleurFondMaillon, couleurBordureMaillon, 2);
}
else//Si on trouver la valeur
{
await algo.colorer(couleurAlgo, 5, Temps.time);
tabInfo[0] = 1;
comPrincipal.disparaitre(1);
comPrincipal.Text = "La valeur " + val + " a été trouvée";
comPrincipal.CouleurFond = couleurtrouve;
comPrincipal.CouleurBordure = couleurtrouve;
this.list[i].opacity = 0.7;
comPrincipal.apparaitre(Temps.time);
await algo.colorer(couleurAlgo, 6, Temps.time);
if (insSup == false)//si la recherche est suivie d'une insértion/suppression
{
this.list[i].colorMaillon(couleurtrouve, couleurtrouve, 2);
this.list[i].colorCase(couleurtrouve, couleurtrouve, 2);
com.disparaitre(0);//faire disparaitre le commentaire
this.list[i].clignoter(couleurtrouve, couleurtrouve, 2, 4);
await Task.Delay(TimeSpan.FromSeconds(4));
}
else
{
this.list[i].colorMaillon(couleurtrouve, couleurtrouve, 2);
this.list[i].colorCase(couleurtrouve, couleurtrouve, 2);
com.disparaitre(0);//faire disparaitre le commentaire
}
await algo.colorer(couleurAlgo, 9, 0.5 *Temps.time);
}
await algo.colorer(couleurAlgo, 10, 0.5 *Temps.time);
i++;
}
await algo.colorer(couleurAlgo, 11, 0.5 *Temps.time);
}
if (tabInfo[0] == 0)//Si on a pas trouvé la valeur
{
comPrincipal.disparaitre(2.5);
comPrincipal.Width = 200;
comPrincipal.Text = "La valeur " + val + " n'a pas été trouvée";
comPrincipal.CouleurFond = couleurparcours;
comPrincipal.CouleurBordure = couleurparcours;
comPrincipal.apparaitre(Temps.time);
com.enleverCanvas(c);
if (!triee)
{
tabInfo[1] = tabInfo[1] - 1;
}
}
comPrincipal.disparaitre(2);
await algo.colorer(couleurAlgo, 12, Temps.time);
algo.disparaitre(Algo); //faire disparaitre l'algorithme déroulant
foreach (Maillon maillon in list) //Remettre les maillons de la liste en leurs couleurs d'origine
{
maillon.colorMaillon(couleurFondMaillon, couleurBordureMaillon, 2);
maillon.colorCase(couleurFondCase, couleurBordureMaillon, 2);
}
}
public async Task insert(int val, Canvas c, Commentaire comPrincipal, Canvas Algo)
{
//Insertion de la valeur val dans la liste
int[] tabInfo = new int[2];
int pos = 0;
Algo algo = new Algo(11, coordX_Algo, coordY_Algo);
if (list.Count != 0)//Recherche si la valeur existe dans la liste
{
await recherche_seq(val, tabInfo, c, true, comPrincipal, Algo);
await Task.Delay(2000);
}
if (tabInfo[0] == 0)//Si la valeur n'existe pas
{
comPrincipal.Text = "Insertion en cours...";
comPrincipal.CouleurFond = Brushes.Yellow;
comPrincipal.CouleurBordure = Brushes.Black;
comPrincipal.apparaitre(0); //faire apparaitre le commentaire
algo.afficher(Algo); //faire apparaitre l'algorithme déroulant
await algo.colorer(couleurAlgo, 0, Temps.time);
if (this.triee)
{
pos = tabInfo[1];
}
Commentaire com = new Commentaire("Insertion au début de la liste", Brushes.Black, coordX + (pos) * (heightOfmaillon + tailleFleche + 5) + 10, coordY - widthOfmaillon, 200, 30, Brushes.PaleTurquoise, Brushes.White);
if (triee && pos != 0)
{
com.Text = "Insertion à la position : " + pos;
}
Point[] tabPoint = new Point[1];
list.Add(new Maillon()); //ajouter le maillon dans la liste
/******Déroulement de l'algorithme******/
if ((pos == this.list.Count - 1) && (pos != 0)) //insértion en fin de liste
{
await algo.colorer(couleurAlgo, 4, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 5, 0.5 *Temps.time);
}
else if (list.Count - 1 == 0)//insértion en début de liste
{
await algo.colorer(couleurAlgo, 1, 0.5 *Temps.time);
}
else//insértion au milieu de la liste
{
await algo.colorer(couleurAlgo, 4, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 5, 0.5 *Temps.time);
}
for (int i = list.Count - 2; i >= pos; i--) //Décalages des maillons pour l'insertion
{
tabPoint[0] = new Point(coordX + (i + 1) * (heightOfmaillon + tailleFleche + 5) + 10, this.coordY);
list[i].deplacer(tabPoint, 1);
if (i != list.Count - 2)
{
list[i].Adr.decaler(coordX + (i + 2) * (heightOfmaillon + tailleFleche + 5) - tailleFleche + 5, coordX + (i + 2) * (heightOfmaillon + tailleFleche + 5));
}
else
{
list[i].Adr.retirerCanvas(c);
list[i].Adr = new Fleche(coordX + (i + 2) * (heightOfmaillon + tailleFleche + 5) - tailleFleche, list[i].Adr.CoordY, list[i].Adr.Color, (list.Count - 1) * (heightOfmaillon + tailleFleche + 5) + heightOfmaillon + 5, 5, 1);
list[i].Adr.dessiner(Temps.time, c);
}
list[i + 1] = list[i];
}
if ((pos == this.list.Count - 1) && (pos != 0))//Si le maillon a inséré est à la fin de la liste
{
list[pos] = new Maillon(val, coordX + (pos) * (heightOfmaillon + tailleFleche + 5) + 10, this.coordY, widthOfmaillon, heightOfmaillon, couleurFondMaillon, couleurBordureMaillon, 2, 5, 1, (list.Count - 1) * (heightOfmaillon + tailleFleche + 5) + heightOfmaillon + 5);
list[pos - 1].Adr.retirerCanvas(c);
list[pos - 1].Adr = new Fleche(list[pos - 1].CoordX + heightOfmaillon - 5, list[pos - 1].Adr.CoordY, list[pos - 1].Adr.Color, tailleFleche, 1, 1);
list[pos - 1].Adr.dessiner(Temps.time, c);
}
else if (list.Count - 1 == 0)//Si la liste est vide
{
list[pos] = new Maillon(val, coordX + (pos) * (heightOfmaillon + tailleFleche + 5) + 10, this.coordY, widthOfmaillon, heightOfmaillon, couleurFondMaillon, couleurBordureMaillon, 2, 5, 1, heightOfmaillon + 5);
}
else
{
list[pos] = new Maillon(val, coordX + (pos) * (heightOfmaillon + tailleFleche + 5) + 10, this.coordY, widthOfmaillon, heightOfmaillon, couleurFondMaillon, couleurBordureMaillon, 2, 1, 1, tailleFleche);
}
list[pos].appear(c); //faire apparaitre le maillon à insérer
com.ajouterCanvas(c); //ajouter le commentaire
if ((pos == this.list.Count - 1) && (pos != 0)) //insértion en fin de liste
{
await algo.colorer(couleurAlgo, 6, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 7, 0.5 *Temps.time);
}
else if (list.Count - 1 == 0)//insértion en début de liste
{
await algo.colorer(couleurAlgo, 2, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 3, 0.5 *Temps.time);
}
else//insértion au milieu de la liste
{
await algo.colorer(couleurAlgo, 6, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 7, 0.5 *Temps.time);
}
com.apparaitre(0.5); // faire apparaitre le commentaire
com.disparaitre(2000); //faire disparaitre le commentaire
await Task.Delay(2000);
await algo.colorer(couleurAlgo, 8, Temps.time);
com.enleverCanvas(c);
}
else//si la valeur a été trouvée dans la liste
{
comPrincipal.Text = "Insertion impossible.\nLa valeur existe déjà";
comPrincipal.CouleurFond = Brushes.Red;
comPrincipal.CouleurBordure = Brushes.Red;
comPrincipal.apparaitre(0);//faire apparaitre le commentaire
await Task.Delay(2000);
}
comPrincipal.disparaitre(1); //faire disparaitre le commentaire
algo.disparaitre(Algo); //faire disparaitre l'algorithme déroulant
}
public async Task insert(int val, Canvas c, Commentaire comPrincipal, Canvas Alg)
{
int[] tabInfo = new int[2];
int pos = 0;
Algo algo = new Algo(13, coordX_Algo, coordY_Algo);
if (list.Count != 0)
{
await recherche_seq(val, tabInfo, c, true, comPrincipal, Alg); //recherche de la valeur dans la liste
}
if (tabInfo[0] == 0) //si la valeur n'existe pas dans la liste
{
comPrincipal.Text = "Insertion en cours...";
comPrincipal.CouleurFond = Brushes.Yellow;
comPrincipal.CouleurBordure = Brushes.Black;
comPrincipal.apparaitre(0); // faire apparaitre le commentaire
algo.afficher(Alg); // faire apparaitre l'algorithme déroulant
await algo.colorer(couleurAlgo, 0, Temps.time);
if (this.triee)
{
pos = tabInfo[1];
}
Commentaire com = new Commentaire("Insertion à la tête de la liste", Brushes.Black, coordX + (pos) * (heightOfmaillon + tailleFleche + 5) + 10, coordY - widthOfmaillon, 200, 30, Brushes.PaleTurquoise, Brushes.White);
if (triee && pos != 0)
{
com.Text = "Insertion à la position : " + pos;
}
Point[] tabPoint = new Point[1];
list.Add(new Maillon_bi()); //ajouter le maillon dans la liste
if (list.Count - 1 == 0) //si la liste est vide
{
await algo.colorer(couleurAlgo, 1, Temps.time);
await algo.colorer(couleurAlgo, 2, Temps.time);
}
else if (pos == 0)//insértion à la première position
{
await algo.colorer(couleurAlgo, 5, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 6, 0.5 *Temps.time);
}
else if (pos == this.list.Count - 1)//insértion à la dernière position
{
await algo.colorer(couleurAlgo, 5, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 6, 0.5 *Temps.time);
}
else//insértion au milieu de la liste
{
await algo.colorer(couleurAlgo, 5, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 6, 0.5 *Temps.time);
}
for (int i = list.Count - 1; i > pos; i--)//décalage des maillon pour l'insértion
{
tabPoint[0] = new Point(coordX + i * (heightOfmaillon + tailleFleche) + tailleFleche, this.coordY);
list[i - 1].deplacer(tabPoint, 1);
list[i - 1].Adr.decaler(tabPoint[0].X + heightOfmaillon - 5, tabPoint[0].X + heightOfmaillon + tailleFleche - 5);
list[i - 1].Prec.decaler(tabPoint[0].X + 5, tabPoint[0].X - tailleFleche + 5);
list[i] = list[i - 1];
}
if (list.Count - 1 == 0)//liste vide
{
list[0] = new Maillon_bi(val, coordX + tailleFleche, coordY, widthOfmaillon, heightOfmaillon, couleurFondMaillon, couleurBordureMaillon, 2, 2, 1, 3, 3, tailleFleche);
}
else if (pos == 0)//insértion en début de liste
{
list[pos] = new Maillon_bi(val, coordX + (pos) * (heightOfmaillon + tailleFleche) + tailleFleche, this.coordY, widthOfmaillon, heightOfmaillon, couleurFondMaillon, couleurBordureMaillon, 2, 2, 1, 3, 1, tailleFleche);
list[1].Prec.retirerCanvas(c);
list[1].Prec = new Fleche(list[0].Adr.CoordX + tailleFleche + 10, list[1].Prec.CoordY, list[1].Prec.Color, tailleFleche, 2, 2);
}
else if (pos == this.list.Count - 1)//insértion en fin de liste
{
list[pos] = new Maillon_bi(val, coordX + (pos) * (heightOfmaillon + tailleFleche) + tailleFleche, this.coordY, widthOfmaillon, heightOfmaillon, couleurFondMaillon, couleurBordureMaillon, 2, 2, 1, 2, 3, tailleFleche);
list[pos - 1].Adr.retirerCanvas(c);
list[pos - 1].Adr = new Fleche(list[pos - 1].CoordX + heightOfmaillon - 5, list[pos - 1].Adr.CoordY, list[pos - 1].Adr.Color, tailleFleche, 1, 1);
await list[pos - 1].Adr.dessiner(Temps.time, c);
}
else//insértion au milieu
{
list[pos] = new Maillon_bi(val, coordX + (pos) * (heightOfmaillon + tailleFleche) + tailleFleche, this.coordY, widthOfmaillon, heightOfmaillon, couleurFondMaillon, couleurBordureMaillon, 2, 2, 1, 2, 1, tailleFleche);
}
list[pos].appear(c);//faire apparaitre le maillon à insérer
if (list.Count - 1 != 0 && pos == 0)
{
await list[1].Prec.dessiner(Temps.time, c);
}
com.ajouterCanvas(c);
com.apparaitre(0.5); //faire apparaitre le commentaire
if (list.Count - 1 == 0) //liste vide
{
await algo.colorer(couleurAlgo, 3, Temps.time);
await algo.colorer(couleurAlgo, 4, Temps.time);
}
else if (pos == 0)//insértion en début de liste
{
await algo.colorer(couleurAlgo, 7, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 8, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 9, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 10, 0.5 *Temps.time);
}
else if (pos == this.list.Count - 1)//insértion en fin de liste
{
await algo.colorer(couleurAlgo, 7, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 8, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 9, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 10, 0.5 *Temps.time);
}
else//insértion au milieu de la liste
{
await algo.colorer(couleurAlgo, 7, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 8, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 9, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 10, 0.5 *Temps.time);
}
com.disparaitre(2000);//faire disparaitre le commentaire
await Task.Delay(2000);
await algo.colorer(couleurAlgo, 11, Temps.time);
com.enleverCanvas(c);//faire disparaitre le commentaire
}
else//si la valeur a été trouvée dans la liste
{
comPrincipal.Text = "Insertion impossible.\nLa valeur existe déjà";
comPrincipal.CouleurFond = Brushes.Red;
comPrincipal.CouleurBordure = Brushes.Red;
comPrincipal.apparaitre(0);// faire apparaitre le commentaire
await Task.Delay(2000);
}
comPrincipal.disparaitre(1); //faire disparaitre le commentaire
algo.disparaitre(Alg); //faire disparaitre l'algorithme déroulant
}
public async Task recherche_seq_qeue(int val, int[] tabInfo, Canvas c, Boolean insSup, Commentaire comPrincipal, Canvas Alg)
{
//recherche de la valeur val et returne indice qui se trouve dans tabInfo
int i = list.Count - 1;
tabInfo[0] = 0;
Algo algo = new Algo(12, coordX_Algo, coordY_Algo); //Création d'un algorithme de déroulement
SolidColorBrush couleurparcours = Brushes.Red;
SolidColorBrush couleurtrouve = Brushes.Green;
Commentaire com = new Commentaire(" ", Brushes.Black, this.coordX - 5, this.coordY - 35, 50, 50, couleurparcours, couleurparcours);
comPrincipal.CouleurFond = Brushes.Yellow;
comPrincipal.CouleurBordure = Brushes.Black;
comPrincipal.apparaitre(1);
comPrincipal.Text = "Recherche en cours ...";
algo.afficher(Alg); //Affichage de l'algorithme
await algo.colorer(couleurAlgo, 0, 0.5 *Temps.time); //Déroulement de l'algorithme
await algo.colorer(couleurAlgo, 1, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 2, 0.5 *Temps.time);
await algo.colorer(couleurAlgo, 3, 0.5 *Temps.time);
com.ajouterCanvas(c);
com.disparaitre(0);
com.opacity = 0;
com.Height = 30;
com.Width = 160;
Fleche parcours = new Fleche(1);
parcours.Height = -tailleFleche;
parcours.StrokeThick = 3;
parcours.Color = couleurparcours;
parcours.L.Opacity = 0.9;
parcours.CoordY = this.coordY + 2 * widthOfmaillon / 3;
if (this.triee == false) //Si la liste n'est pas triée
{
while (i >= 0 & tabInfo[0] == 0) //Si on est pas arriver à la fin de la liste
{
await algo.colorer(couleurAlgo, 4, 0.5 *Temps.time);
this.list[i].opacity = 0.7;
if (this.list[i].Valeur != val)//Si la valeur du maillon est différente de la valeur rechercher
{
com.CoordX = this.list[i].CoordX;
com.CoordY = this.list[i].CoordY - 35;
this.list[i].colorMaillon(couleurparcours, couleurBordureMaillon, 2);//On colorie en gris le maillon
this.list[i].colorCase(couleurparcours, couleurBordureMaillon, 2);
com.Text = " " + this.list[i].Valeur + " est différent de " + val;
com.apparaitre(Temps.time);//On affiche le commantaire que la valeur du maillon est différente de la valeur rechercher
await algo.colorer(couleurAlgo, 7, 0.5 *Temps.time);
parcours.CoordX = list[i].Prec.CoordX;
parcours.bout = new Bout(list[i].Prec.bout.coordX, list[i].Prec.bout.coordY, couleurparcours, list[i].Prec.bout.TypeBout, 2.5);
await parcours.dessiner(Temps.time, c);
await algo.colorer(couleurAlgo, 8, Temps.time);
parcours.retirerCanvas(c);
com.disparaitre(0);
this.list[i].colorMaillon(Brushes.Gainsboro, couleurBordureMaillon, 2); tabInfo[1] = tabInfo[1] + 1;
this.list[i].colorCase(Brushes.Gainsboro, couleurBordureMaillon, 2);
}
else//Si on a trouver la valeur
{
await algo.colorer(couleurAlgo, 5, Temps.time);
tabInfo[0] = 1;
comPrincipal.disparaitre(1);
comPrincipal.Text = "La valeur " + val + " a été trouvée";
comPrincipal.CouleurFond = couleurtrouve;
comPrincipal.CouleurBordure = couleurtrouve;
this.list[i].opacity = 0.7;
comPrincipal.apparaitre(Temps.time);
await algo.colorer(couleurAlgo, 6, Temps.time);
if (insSup == false)
{
this.list[i].colorMaillon(couleurtrouve, couleurtrouve, 2);
this.list[i].colorCase(couleurtrouve, couleurtrouve, 2);
com.disparaitre(0);
// this.list[i].vibrate(4, 19);
this.list[i].clignoter(couleurtrouve, couleurtrouve, 2, 3);
await Task.Delay(TimeSpan.FromSeconds(4));
}
else
{
this.list[i].colorMaillon(couleurtrouve, couleurtrouve, 2);
this.list[i].colorCase(couleurtrouve, couleurtrouve, 2);
com.disparaitre(0);
}
await algo.colorer(couleurAlgo, 9, 0.5 *Temps.time);
}
i--;
await algo.colorer(couleurAlgo, 10, 0.2 *Temps.time);
}
await algo.colorer(couleurAlgo, 11, 0.2 *Temps.time);
}
else
{
parcours.CoordX = heightOfmaillon + list[i].CoordX;
while (i >= 0 && tabInfo[0] == 0 && list[i].Valeur >= val)
{
await algo.colorer(couleurAlgo, 4, 0.5 *Temps.time);
this.list[i].opacity = 0.7;
if (this.list[i].Valeur != val)
{
com.CoordX = this.list[i].CoordX;
com.CoordY = this.list[i].CoordY - 35;
this.list[i].colorMaillon(couleurparcours, couleurBordureMaillon, 2);
this.list[i].colorCase(couleurparcours, couleurBordureMaillon, 2);
com.Text = " " + this.list[i].Valeur + " est différent de " + val;
com.apparaitre(Temps.time);
await algo.colorer(couleurAlgo, 7, 0.5 *Temps.time);
parcours.CoordX = list[i].Prec.CoordX;
parcours.bout = new Bout(list[i].Prec.bout.coordX, list[i].Prec.bout.coordY, couleurparcours, list[i].Prec.bout.TypeBout, 2.5);
await parcours.dessiner(Temps.time, c);
await algo.colorer(couleurAlgo, 8, Temps.time);
parcours.retirerCanvas(c);
com.disparaitre(0);
this.list[i].colorMaillon(Brushes.Gainsboro, couleurBordureMaillon, 2); tabInfo[1] = tabInfo[1] + 1;
this.list[i].colorMaillon(Brushes.Gainsboro, couleurBordureMaillon, 2);
}
else//Si on trouver la valeur
{
await algo.colorer(couleurAlgo, 5, Temps.time);
tabInfo[0] = 1;
comPrincipal.disparaitre(1);
comPrincipal.Text = "La valeur " + val + " a été trouvée";
comPrincipal.CouleurFond = couleurtrouve;
comPrincipal.CouleurBordure = couleurtrouve;
this.list[i].opacity = 0.7;
comPrincipal.apparaitre(Temps.time);
await algo.colorer(couleurAlgo, 6, Temps.time);
if (insSup == false)//si la recherche n'est pas suivie d'une insértion/suppression
{
this.list[i].colorMaillon(couleurtrouve, couleurtrouve, 2);
this.list[i].colorCase(couleurtrouve, couleurtrouve, 2);
com.disparaitre(0);
this.list[i].clignoter(couleurtrouve, couleurtrouve, 2, 3);
await Task.Delay(TimeSpan.FromSeconds(4));
}
else
{
this.list[i].colorMaillon(couleurtrouve, couleurtrouve, 2);
this.list[i].colorCase(couleurtrouve, couleurtrouve, 2);
com.disparaitre(0);
}
await algo.colorer(couleurAlgo, 9, 0.5 *Temps.time);
}
await algo.colorer(couleurAlgo, 10, 0.5 *Temps.time);
i--;
}
await algo.colorer(couleurAlgo, 11, 0.5 *Temps.time);
}
if (tabInfo[0] == 0)
{
comPrincipal.disparaitre(2.5);// faire disparaitre le commentaire
comPrincipal.Text = "La valeur " + val + " n'a pas été trouvée";
comPrincipal.CouleurFond = couleurparcours;
comPrincipal.CouleurBordure = couleurparcours;
comPrincipal.apparaitre(Temps.time);//apparition du commentaire
com.enleverCanvas(c);
if (!triee)
{
tabInfo[1] = tabInfo[1] + 1; //si la liste n'est pas triée
}
}
comPrincipal.disparaitre(2);//faire disparaitre le commentaire
await algo.colorer(couleurAlgo, 12, Temps.time);
algo.disparaitre(Alg);//faire disparaitre l'algorithme déroulant
foreach (Maillon maillon in list)
{
maillon.colorMaillon(couleurFondMaillon, couleurBordureMaillon, 2);
maillon.colorCase(couleurFondCase, couleurBordureMaillon, 2);
}
}