Algorithmique et Structures de Données

Devoir surveillé Avril 2001 - MASS2 et MIAGE 1
Durée 2 heures
Documents et calculatrices non autorisées


Question de cours (4 points)

Faire tourner les algorithmes de tri par sélection et de tri insertion sur l'exemple [4,7,2,10,3]. On se contentera ici de décrire les états successifs du tableau depuis l'état initial jusqu'à la fin du tri. Le code de ces algorithmes est donné en annexe.


Problème : Tableau unimodal (16 points)

On dit qu'une tableau d'entiers est unimodal lorsque la suite de ses valeurs sont d'abord en ordre croissant puis en ordre décroissant. Ainsi le tableau [7,9,12,10,8,6,5,4] est unimodal mais [3,2,5] ne l'est pas. Notez que la partie croissante (resp. décroissante) peut être vide si bien que [1,2,3] ou [3,2,1] sont également unimodaux. Pour simplifier, on supposera que les tableaux considérés ont des valeurs distinctes et sont de taille supérieure ou égale à deux. On demande évidemment de proposer des algorithmes qui utilisent la propriété d'unimodalité.

  1. Ecrire une méthode public int minimum() qui retourne la valeur minimum d'un tableau unimodal.
  2. Ecrire une méthode public int indiceDuMaximum() qui retourne l 'indice du maximum d'un tableau unimodal et une méthode public int maximum() qui retourne la valeur de ce maximum.
  3. Ecrire une méthode public int deuxiemeMinimum() qui retourne la valeur du deuxième minimum d'un tableau unimodal, c'est à dire la plus petite des valeurs strictement supérieures au minimum.
  4. Ecrire une méthode public int deuxiemeMaximum() qui retourne le deuxième maximum d'un tableau unimodal, c'est à dire la plus grande des valeurs strictement inférieures au maximum.
  5. Ecrire une méthode public int kiemeValeur(int k) qui retourne la kième valeur d'un tableau unimodal depuis la plus petite, c'est à dire la kième des valeurs en ordre croissant.. La fonction retournera -1 si l'on dépasse les bornes. Un exemple est donné en commentaire du programme fourni en annexe.
  6. Ecrire une méthode public boolean estUnimodal() qui teste si un tableau est ou non unimodal.
  7. (BONUS) Adapter l'algorithme de tri insertion au tri d'un tableau unimodal.



Annexe. La classe TriTableau du cours

public class TriTableau{

    private int contenu[]; 
    private int taille;
    
    public TriTableau(int t[]){ 
       taille=t.length;
       contenu=t; 
       }  
    

    public String toString(){
        String s="[";
        for(int i=0;i<taille-1;i++) 
	s=s+contenu[i]+",";
        s=s+contenu[taille-1]+"]";
        return(s);
    }

    public void echange(int i, int j){ 
        int x=contenu[i]; 
        contenu[i]=contenu[j];
        contenu[j]=x; 
    }
 
     public static int min(int a, int b){
         if(a<b) 
	 return(a);
          else 
	  return(b);
      }

     public static int max(int a, int b){
         if(a<b) 
	 return(b);
          else 
	  return(a);
      }
      
    	public int indiceDuMinimumAPartirDe(int i){
       int indiceMinimum=i;
       int j=i+1;
       while(j<taille){
           if(contenu[j]<contenu[indiceMinimum])
               indiceMinimum=j;
           j++;
        }
        return(indiceMinimum);
     }

     public void triSelection(){
         for(int i=0;i<taille;i++)
            echange(i,indiceDuMinimumAPartirDe(i));
     } 
	
	public void triInsertion(){
        int j;
        for(int i=1;i<taille;i++){ 
             for(j=0;contenu[j]<contenu[i];j++);
             for(int k=i;k>j;k--)
                 contenu[k]=contenu[k-1];
             contenu[j]=tampon;
        }
	}
/*****************************************************************************
**                            METHODES A COMPLETER/MODIFIER                 **
*****************************************************************************/  
     //Question 1
	public int minimum(){
		return(0);
	}

     //Question 2
 	public int indiceDuMaximum() {
		return(0);
	}
	public int maximum(){
		return(0);
	}
	
     //Question 3
	public int deuximeMinimum(){
		return(0);
	}

     //Question 4
	public int deuxiemeMaximum(){
		return(0);
	}
	
     //Question 5
	public int kiemeValeur(int k) {
		return(0);
	} 
	
     //Question 6
	public boolean estUnimodal() {
		return(true);
	} 
   
     //Question 7
    	public void triInsertionUnimodal(){
     }
 
      

/*****************************************************************************
**                            UNE METHODE MAIN POUR TESTER                  **
*****************************************************************************/  

 	public static void main(String args[]) { 
        int [] tt={7,9,12,10,8,6,5,4};
        TriTableau t=new TriTableau(tt);
        if(t.estUnimodal()){
            System.out.println(t+" est unimodal, "+ " de minimum "
				+ t.minimum()+" de maximum "+t.maximum());
            System.out.println( " Son  deuxième  minimum est "
				+ t.deuxiemeMinimum());           
            System.out.println( " Son  deuxième  maximum est "
				+ t.deuxiemeMaximum());           
		  for(int i=0;i<tt.length+2;i++)
	    		System.out.println("Le tableau unimodal " + t 
				+" a pour "+i+ "ème valeur  : " + t.kiemeValeur(i));
		  t.triInsertionUnimodal();
		  System.out.println("Le tableau trié est "+ t);	
        }
    }
}


/*****************************************************************************
**             Le résultat de l'exécution du programme précédent            **
*****************************************************************************/  

/**
 *  [7,9,12,10,8,6,5,4] est unimodal :  de minimum 4 de maximum 12
 *  Son  deuxième  minimum est 5
 *  Son  deuxième  maximum est 10
 * Le tableau unimodal [7,9,12,10,8,6,5,4] a pour 0ème valeur  : -1
 * Le tableau unimodal [7,9,12,10,8,6,5,4] a pour 1ème valeur  : 4
 * Le tableau unimodal [7,9,12,10,8,6,5,4] a pour 2ème valeur  : 5
 * Le tableau unimodal [7,9,12,10,8,6,5,4] a pour 3ème valeur  : 6
 * Le tableau unimodal [7,9,12,10,8,6,5,4] a pour 4ème valeur  : 7
 * Le tableau unimodal [7,9,12,10,8,6,5,4] a pour 5ème valeur  : 8
 * Le tableau unimodal [7,9,12,10,8,6,5,4] a pour 6ème valeur  : 9
 * Le tableau unimodal [7,9,12,10,8,6,5,4] a pour 7ème valeur  : 10
 * Le tableau unimodal [7,9,12,10,8,6,5,4] a pour 8ème valeur  : 12
 * Le tableau unimodal [7,9,12,10,8,6,5,4] a pour 9ème valeur  : -1
 * Le tableau trié est [4,5,6,7,8,9,10,12]
 */