tri rapide Notes d'étude

Trier rapide

 

 

 

---

Processus de commande

L'idée de base

tri rapide et tri à bulles, est basée sur la comparaison et l'échange d'algorithmes de tri, tri rapide basé sur l'idée de diviser pour mieux régner, Bubble est optimisé Trier.

L'idée de base est la suivante : choisir une séquence à partir d' un élément de référence , une séquence en deux parties, dans lequel une partie de l'élément est plus petit que l'autre partie de l'élément, puis répéter le processus pour chacune des deux parties, l'ensemble du processus de tri peut être récursive.

      

 

---

 

(1) un élément choisi parmi la séquence d'élément de référence ( élément de référence sélectionné aura une incidence sur l'efficacité du tri );

(2) en utilisant l'élément de référence se séquencer en deux sous-séquences, dans lequel tous les éléments d'une séquence sont plus petites que l'autre séquence;

(3) la sous-séquence se répète jusqu'à ce que le processus est la séquence d'un seul élément.

 

Le processus de la figure sur une séquence utilisée comme élément de référence du premier élément

analyse

 

 1, lors de l'utilisation d'un tri rapide plus approprié? Tri rapide Pourquoi rapide?

    Plus la taille des données, plus d'excellentes performances de tri rapide. Les avantages et les commandes rapides dans, sans supplément par rapport au nombre moins global de comparaisons.

2, le meilleur des cas, le pire des cas? (Dans l'ordre croissant, par exemple)

 

 

 Mentionné ci-dessus, le critère de sélection aura une incidence sur l'efficacité du tri des éléments dans le pire des cas, les éléments de référence sont choisis chacun intervalle plus petit élément, le meilleur des cas, les éléments de référence sont chaque intervalle valeur intermédiaire sélectionné.

Le pire cas:

    Le pire des cas, un total de division de temps n-1.

    Lorsque le i-ème longueur d' intervalle divisé de ni + 1 (suite arithmétique, la durée de formule A _i  = A _{. 1} + (. 1-n) D), ni pour les comparaisons.

Pour un total de n (n-1) / 2 comparaisons (sommation de séquence arithmétique), la complexité en temps de O (n - ² ).

Meilleur cas:

    Au mieux, un total de n fois divisé.

    La complexité en temps de O (nlog ^n- ).

La complexité temporelle moyenne: O (nlog ₂ ^n- )

code:

 

1      / * 
2       * sections divisées
 3.       De *
 4.       * @Param randomArray - pour être séquence triée
 5.       * @Param Low - Intervalle inférieur tri Bound
 . 6       * @param haut - tri des limites d' intervalle
 7.       * @Return - Après la division, où l'élément de référence la position
 . 8       * / 
9.      publique  statique  int Divide (entier [] randomArray, int bas, int haut) {
 10          // Si seulement deux éléments d' intervalle 
11.          IF (. haut - Bas == 1 ) {
 12 est              int TEMP;
13 est              SI (randomArray [Low]> randomArray [haut]) {
 14                  TEMP = randomArray [Low];
 15                  randomArray [Low] = randomArray [haut];
 16                  randomArray [haut] = TEMP;
 . 17              }
 18 est              retour -1 ;
 . 19          }
 20          // 1, sélectionner l'élément de référence 
21 est          int datum = faible;
 22 est          // 2, traversant l' intervalle, l' intervalle divisé. 
23 est          int TEMP;
 24          le tout (Low < High) {
 25              //
 26 est             tandis que (faible <&& haute randomArray [basse] <= randomArray [donnée]) {
 27                  faible ++ ;
28              }
 29              //
 30              tandis que (haut> bas && randomArray [haut]> randomArray [donnée]) {
 31                  high-- ;
32              }
 33              temp = randomArray [basse];
34              randomArray [basse] = randomArray [haut];
35              randomArray [élevée] = température;
36          }
 37          // 交换基准元素至正确位置
38          temp =randomArray [donnée];
39          randomArray [donnée] = randomArray [bas - 1 ];
40          randomArray [bas - 1] = température;
41          rendement faible - 1 ;
42      }

 

 

1      / * 
2       * Quicksort
 3.       *
 4.       * @Param randomArray - pour être séquence triée
 5.       * @Param Low - Intervalle inférieur tri Bound
 . 6       * @param haut - Section supérieure de tri Bound
 . 7       * @return - séquence ordonnée de
 8       * / 
9      publique  statique Integer [] quickSorted (Integer [] randomArray, int bas, int haut) {
 10          // intervalle supérieur à 1 seuls éléments tri nécessaire 
11.          IF (High - Low> = 1 ) {
 12 est              // 1, la section de division 
13             int Datum = Diviser (randomArray, Bas, Haut),
 14              // 2, que ce soit de continuer à diviser 
15              IF (Datum = -1! {)
 16                  quickSorted (randomArray, Low, Datum - 1. );
 17.                  quickSorted (randomArray, Datum + . 1 , élevé),
 18 est              }
 . 19          }
 20 est          retour randomArray;
 21 est      }