Le but est de permuter les valeurs de deux variables a et b, en utilisant une troisième variable temporaire.

Cliquez ici pour afficher la version pseudo-langage.

c = a;
a = b;
b = c;

Cliquez ici pour un fichier de test complet.

public class Main

{

    public static void main( String[] args )

    {

        int a=1;

        int b=2;

        System.out.println("Avant l'echange :");

        System.out.print("a vaut : ");

        System.out.println(a);

        System.out.print("b vaut : ");

        System.out.println(b);

        

        int c=a;

        a=b;

        b=c;

        

        System.out.println("Apres l'echange :");

        System.out.print("a vaut : ");

        System.out.println(a);

        System.out.print("b vaut : ");

        System.out.println(b);

    }

}

Pour afficher un tableau, on a besoin du tableau en question (appelons-le T) et, dans certains langages, de la taille du tableau (en Java, on peut, à partir du tableau seul, connaître sa taille, mais dans d'autres langages comme le C, on ne peut pas, il faut donc conserver la taille du tableau dans une variable). On parcourt le tableau pour l'afficher case par case.

Cliquez ici pour afficher la version pseudo-langage.

Pour cpt allant de 0 à (taille_du_tableau-1)
  |  Afficher T[cpt]

Cliquez ici pour la version Java.

public static void afficher_tableau(int[] T)

{

    int cpt;



    for(cpt=0; cpt<T.length; cpt=cpt+1)

    {

        System.out.println(T[cpt]);

    }

}

Cliquez ici pour un fichier de test complet.

public class Main

{

    public static void main( String[] args )

    {

        int[] tab = new int[6];

        tab[0] = 3;

        tab[1] = 8;

        tab[2] = 2;

        tab[3] = 1;

        tab[4] = 5;

        tab[5] = 4;

        

        afficher_tableau(tab);

    }

    

    public static void afficher_tableau(int[] T)

    {

        int cpt;



        for(cpt=0; cpt<T.length; cpt=cpt+1)

        {

            System.out.println(T[cpt]);

        }

    }

}

On parcourt le tableau T pour faire la somme des tous ses éléments, et à la fin, on divise par le nombre d'éléments. Attention, en Java, il faut calculer la moyenne sur un float ou un double.

Cliquez ici pour afficher la version pseudo-langage.

moyenne = 0;

Pour cpt allant de 0 à (taille_du_tableau-1)
  |  moyenne = moyenne + T[cpt];

moyenne = moyenne / taille_du_tableau;
retourner moyenne;

Cliquez ici pour la version Java.

public static double calculer_moyenne(int[] T)

{

    int cpt;

    double moyenne=0.0;



    for(cpt=0; cpt<T.length; cpt=cpt+1)

    {

        moyenne = moyenne + T[cpt];

    }



    return(moyenne/T.length);

}

Cliquez ici pour un fichier de test complet.

public class Main

{

    public static void main( String[] args )

    {

        int[] tab = new int[6];

        tab[0] = 3;

        tab[1] = 8;

        tab[2] = 2;

        tab[3] = 1;

        tab[4] = 5;

        tab[5] = 4;

        

        System.out.println(calculer_moyenne(tab));

    }

    

    public static double calculer_moyenne(int[] T)

    {

        int cpt;

        double moyenne=0.0;



        for(cpt=0; cpt<T.length; cpt=cpt+1)

        {

            moyenne = moyenne + T[cpt];

        }



        return(moyenne/T.length);

    }

}

On commence par poser comme plus grand élément le premier élément du tableau. On parcourt tout le tableau T, et dès que l'on tombe sur une case contenant un élément plus grand que notre plus grand élément, on met à jour notre plus grand élément.

Cliquez ici pour afficher la version pseudo-langage.

max = T[0];

Pour cpt allant de 1 à (taille_du_tableau-1)
  |  Si T[cpt] est plus grand que max
  |   |   max = T[cpt];

retourner max;

Cliquez ici pour la version Java.

public static int plus_grand_element(int[] T)

{

    int cpt, max;

    max=T[0];

    

    for(cpt=1; cpt<T.length; cpt=cpt+1)

    {

        if( T[cpt] > max )

        {

            max = T[cpt];

        }

    }

    

    return(max);

}

Cliquez ici pour un fichier de test complet.

public class Main

{

    public static void main( String[] args )

    {

        int[] tab = new int[6];

        tab[0] = 3;

        tab[1] = 8;

        tab[2] = 2;

        tab[3] = 1;

        tab[4] = 5;

        tab[5] = 4;

        

        System.out.println(plus_grand_element(tab));

    }

    

    public static int plus_grand_element(int[] T)

    {

        int cpt, max;

        max=T[0];

        

        for(cpt=1; cpt<T.length; cpt=cpt+1)

        {

            if( T[cpt] > max )

            {

                max = T[cpt];

            }

        }

        

        return(max);

    }

}

Pareil que précédemment, si ce n'est que l'on s'intéresse cette fois-ci à la position (et non pas la valeur) du plus grand élément du tableau T.

Cliquez ici pour afficher la version pseudo-langage.

pos_max = 0;

Pour cpt allant de 1 à (taille_du_tableau-1)
  |  Si T[cpt] est plus grand que T[pos_max]
  |   |   pos_max = cpt;

retourner pos_max;

Cliquez ici pour la version Java.

public static int position_plus_grand_element(int[] T)

{

    int cpt, pos_max;

    pos_max=0;

    

    for(cpt=1; cpt<T.length; cpt=cpt+1)

    {

        if( T[cpt] > T[pos_max] )

        {

            pos_max = cpt;

        }

    }

    

    return(pos_max);

}

Cliquez ici pour un fichier de test complet.

public class Main

{

    public static void main( String[] args )

    {

        int[] tab = new int[6];

        tab[0] = 3;

        tab[1] = 8;

        tab[2] = 2;

        tab[3] = 1;

        tab[4] = 5;

        tab[5] = 4;

        

        System.out.println(position_plus_grand_element(tab));

    }

    

    public static int position_plus_grand_element(int[] T)

    {

        int cpt, pos_max;

        pos_max=0;

        

        for(cpt=1; cpt<T.length; cpt=cpt+1)

        {

            if( T[cpt] > T[pos_max] )

            {

                pos_max = cpt;

            }

        }

        

        return(pos_max);

    }

}

On veut trier les éléments d'un tableau, du plus petit au plus grand. Pour ce faire, on parcourt d'abord tout le tableau T et, pour chaque case et sa voisine, si les deux cases ne sont pas de le bon ordre, on permute leur valeur. A la fin du premier parcours, on est sûr que le plus grand élément du tableau est placé à la fin, mais le tableau n'est pas trié.

On refait alors un second parcours, avec les mêmes règles, en ignorant cette fois-ci la dernière case du tableau (car la valeur dans cette case est bien placée, et la parcourir ne changera rien si ce n'est perdre du temps). A la fin de ce parcours, un second élément du tableau est bien placé (le second plus grand élément du tableau est venu se placer à l'avant dernière case).

En répétant cette opération autant de fois qu'il n'y a des cases dans le tableau, on aura trié le tableau. On utilisera une variable limite qui sera placée, au départ de l'algorithme, à l'avant dernière case du tableau : le parcours ne devra pas dépasser limite, et à chaque tour, on reculera cette limite.

Cliquez ici pour afficher la version pseudo-langage.

limite = taille_du_tableau - 1;

Repeter taille_du_tableau-1 fois
  |  Pour i allant de 0 à (limite-1)
  |   |   Si T[i] est plus grand que T[i+1]
  |   |    |   temp=T[i];
  |   |    |   T[i]=T[i+1];
  |   |    |   T[i+1]=temp;
  |  limite = limite-1;

Cliquez ici pour la version Java.

public static void tri_bulle(int[] T)

{

    int cpt, limite, i, temp;

    limite=T.length-1;

    

    for(cpt=0; cpt<T.length-1; cpt=cpt+1)

    {

        for(i=0; i<limite; i=i+1)

        {

            if(T[i] > T[i+1])

            {

                temp=T[i];

                T[i]=T[i+1];

                T[i+1]=temp;

            }

        }

        limite=limite-1;

    }

}

Cliquez ici pour un fichier de test complet.

public class Main

{

    public static void main( String[] args )

    {

        int[] tab = new int[6];

        tab[0] = 3;

        tab[1] = 8;

        tab[2] = 2;

        tab[3] = 1;

        tab[4] = 5;

        tab[5] = 4;

        

        tri_bulle(tab);

        

        afficher_tableau(tab);

    }

    



    public static void tri_bulle(int[] T)

    {

        int cpt, limite, i, temp;

        limite=T.length-1;

        

        for(cpt=0; cpt<T.length-1; cpt=cpt+1)

        {

            for(i=0; i<limite; i=i+1)

            {

                if(T[i] > T[i+1])

                {

                    temp=T[i];

                    T[i]=T[i+1];

                    T[i+1]=temp;

                }

            }

            limite=limite-1;

        }

    }

    



    public static void afficher_tableau(int[] T)

    {

        int cpt;

    

        for(cpt=0; cpt<T.length; cpt=cpt+1)

        {

            System.out.println(T[cpt]);

        }

    }

}

C'est la méthode de tri la plus "naturelle". On parcourt le tableau T à la recherche du plus grand élément, et on permute la dernière case du tableau avec la case contenant le plus grand élément. On recommence une seconde fois en ignorant la dernière case du tableau (où l'on a déjà placé le plus grand élément) : on récupère alors le second plus grand élément du tableau, que l'on place à l'avant dernière case du tableau. On recommence avec le troisième plus grand élément, etc.

En répétant cette opération autant de fois qu'il y a de cases dans le tableau, on est sûr de trier le tableau. On utilisera la fonction position_plus_grand_element_limitee, qui est une modification de la fonction position_plus_grand_element vue précédemment : au lieu de rechercher la position du plus grand élément du tableau, on recherche la position du plus grand élément du tableau situé entre la case 0 et une certaine limite.

A chaque tour, on recherchera la position du plus grand élément du tableau situé situé entre la case 0 et la limite (qui est la variable i). Au début, i (la limite) est égale à la dernière case du tableau, puis, à chaque tour, on recule i. A chaque fois, on place le plus grand élément ainsi trouvé à la case i.

Cliquez ici pour afficher la version pseudo-langage.

**fonction position_plus_grand_element_limitee( tableau T, entier limite )

pos_max = 0;

Pour cpt allant de 1 à limite
  |  Si T[cpt] est plus grand que T[pos_max]
  |   |   pos_max = cpt;

retourner pos_max;

**fonction tri_par_selection( tableau T )

Pour i allant de (taille_du_tableau-1) à 1
  |  position_max = position_plus_grand_element_limitee(T, i);
  |  temp = T[i];
  |  T[i] = T[position_max];
  |  T[position_max] = temp;

Cliquez ici pour la version Java.

public static int position_plus_grand_element_limitee(int[] T, int limite)

{

    int cpt, pos_max;

    pos_max=0;

    

    for(cpt=1; cpt<=limite; cpt=cpt+1)

    {

        if( T[cpt] > T[pos_max] )

        {

            pos_max = cpt;

        }

    }

    

    return(pos_max);

} 

public static void tri_selection(int[] T)

{

    int pos_max, temp, i;

    

    for(i=T.length-1; i>0; i=i-1)

    {

        pos_max = position_plus_grand_element_limitee(T, i);

        temp = T[i];

        T[i] = T[pos_max];

        T[pos_max] = temp;

    }

}

Cliquez ici pour un fichier de test complet.

public class Main

{

    public static void main( String[] args )

    {

        int[] tab = new int[6];

        tab[0] = 3;

        tab[1] = 8;

        tab[2] = 2;

        tab[3] = 1;

        tab[4] = 5;

        tab[5] = 4;

        

        tri_selection(tab);

        

        afficher_tableau(tab);

    }

    

    public static int position_plus_grand_element_limitee(int[] T, int limite)

    {

        int cpt, pos_max;

        pos_max=0;

        

        for(cpt=1; cpt<=limite; cpt=cpt+1)

        {

            if( T[cpt] > T[pos_max] )

            {

                pos_max = cpt;

            }

        }

        

        return(pos_max);

    }    



    public static void tri_selection(int[] T)

    {

        int pos_max, temp, i;

        

        for(i=T.length-1; i>0; i=i-1)

        {

            pos_max = position_plus_grand_element_limitee(T, i);

            temp = T[i];

            T[i] = T[pos_max];

            T[pos_max] = temp;

        }

    }

    

    public static void afficher_tableau(int[] T)

    {

        int cpt;

    

        for(cpt=0; cpt<T.length; cpt=cpt+1)

        {

            System.out.println(T[cpt]);

        }

    }

}