Chapitre base de l'algorithme

insertion Trier

L'insertion fonctionne sorte comme beaucoup de gens disposés dans une main et des cartes à jouer. Dans un premier temps, notre main gauche est vide et la face suivante de la carte sur la table. Ensuite, chaque fois que nous prenons une carte sur la table et l'insérer dans la bonne position dans la main gauche. Pour trouver l'emplacement correct d'une carte, de droite à gauche, nous comparerons avec chaque carte déjà en main, comme le montre la figure.

 code mise en œuvre

template < class T>
 vide InsertionSort (T a [], int nums) {
     pour ( int i = 1 ; i <nums; i ++ ) { 
        T clé = a [i];
        int j = i - 1 ;
        tandis que (j> = 0 && a [j]> key) { 
            a [j + 1 ] = a [j]; 
            j - ; 
        } 
        A [j + 1 =] clé; 
    } 
}

 

Divide and Conquer

De nombreux algorithmes utiles dans la structure est récursive: pour résoudre un problème donné, un ou plusieurs algorithmes appelle lui-même récursive pour résoudre un certain nombre de sous-questions étroitement liées. Ces algorithmes suivent généralement l'idée de diviser pour mieux régner: le problème d'origine en plusieurs plus petite échelle, mais semblable au problème d'origine des sous-problèmes, pour résoudre ces sous-problèmes récursive, puis combiner les solutions de ces sous-questions pour établir la solution du problème d'origine .

Cloison à chaque modèle récursif comporte trois étapes :

• Décomposer le problème d' origine en plusieurs sous-problèmes, ces sous-problèmes sont plus petits exemples du problème d' origine.
• Résoudre ces sous-problèmes, la résolution récursive chaque sous-problème. Ensuite, si la taille des sous-problèmes est assez petit, la solution directe.
• La combinaison solution de ces sous-solution du problème au problème initial.

Tri par fusion algorithme en pleine conformité avec le mode sous-règle. fonctionne de manière intuitive comme suit:

• Décomposition : La séquence comporte n éléments à trier en deux sous-séquences ayant chacun n / 2 éléments.
• Solution : tri par fusion récursive deux séquences alignées.
• Fusion : fusion de deux séquences triées.

Lorsque la longueur de la séquence à trier est 1, récursive « a commencé à augmenter, » ne faire aucun travail dans ce cas, parce que la longueur de chaque séquence ont été triés.

code mise en œuvre

template < class T>
 vide fusion (T a, [] int p, int q, int r) {
     int n1 = q - p + 1 , n2 = r - q; 
    T * gauche = nouveau T [n1 + 1 ], * droite = nouveau T [+ n2 1 ]; 

    pour ( int i = 0 ; i <n1; i ++ ) { 
        gauche [i] = a [p + i]; 
    } 
    Gauche [n1] = max;
    pour ( int i = 0; i <n2; i ++ ) { 
        droite [i] = a [q + i + 1 ]; 
    } 
    Droite [n2] = max; 

    int i = 0 , j = 0 ;
    pour ( int k = p; k <= r; k ++ ) {
         si (gauche [i] < droite [j]) { 
            a [k] = gauche [i]; 
            i ++ ; 
        } 
        Autre { 
            a [k] = [j] droit; 
            j ++ ; 
        } 
    } 
} 

Modèle< Class T>
 vide mergesort (T a [], int p, int r) {
     si (p < r) {
         int q = (p + r) / 2 ; 
        Mergesort (a, p, q); 
        Mergesort (a, q + 1 , r); 
        Fusionner (a, p, q, r); 
    } 
}