Algoritmo de Projeto e Análise (c) dividir e conquistar - classificação rápida de recursiva e não-recursiva

recursiva

#include <stdio.h> usando namespace std;
int partição ( int s [], int l, int r);
vazio QuickSort ( int s [], int l, int r); int main () {
    int s [ 9 ] = { 7 , 5 , 4 , 6 , 2 , 3 , 1 , 9 , 8 }; 
   QuickSort (s, 0 , 8 );
   para (

 

int I = 0 ; <I . 9 ; i ++) a printf ( " % D " , S [I]); 
} 

int partição ( int S [], int L, int P & lt) {
     SE (G> = P & lt) retorno G;
     int pivô S = [L]; // cubo tem um primeiro número 
    do tempo (L < P & lt) {
         a, enquanto (L <P & lt && S [I & lt]> = Pivot) r--; // a partir da direita do cubo é menos do que a verificação 
        IF (L <P & lt) S [G] = S [I & lt]; // para um pequeno valor para a esquerda, de 

        a, enquanto (L <P & lt && S [G] <= Pivot) L ++ ;
         IF (L <P & lt) S [I & lt] = S [G];
    } 
    S [G] = pivô; // cavado poço recordar para preencher 
    retorno G; // retornar a posição do cubo 
} 

vazio QuickSort ( int S [], int L, int P & lt) {
     SE (L < P & lt) {
         int pivotIndex = partição (S, L, P & lt); 
        quickSort (S, G, pivotIndex - 1. ); 
        quickSort (S, pivotIndex + . 1 , R & lt); 
    } 
} 
// fonte de referência é QuickSort.h

 

Não recursivo

#include <stdio.h> 
#include <pilha> usando namespace std;
int partição ( int s [], int l, int r);
vazio quickSort_stack ( int s [], int n); int main () {
    int s [ 9 ] = { 7 , 5 , 4 , 6 , 2 , 3 , 1 , 9 , 8 }; 
   quickSort_stack (s, 9 );
   para ( int

 

I = 0 ; <I . 9 ; i ++) a printf ( " % D " , S [I]); 
} 

int partição ( int S [], int L, int P & lt) {
     SE (G> = P & lt) retorno G;
     int S = pivô [L]; // cubo tem um primeiro número 
    do tempo (L < P & lt) {
         a, enquanto (L <P & lt && S [I & lt]> = Pivot) r--; // a partir da direita é menos do que o cubo de verificação 
        se (L <P & lt) S [G] = S [I & lt]; // para um pequeno valor para a esquerda, de 

        a, enquanto (L <P & lt && S [G] <= Pivot) L ++ ;
         IF (L <P & lt) S [I & lt] = S [G]; 
    } 
    S [G]Pivô =; // cavado poço recordar para preenchimento 
    retorno G; // retornar a posição do cubo 
} 

vazio quickSort_stack ( int Um [], int n-) {
     int G = 0 , I & lt = N- 1. ; 
    Stack < int > S; 
    s.push (L); 
    s.push (P & lt); 
    o tempo (! s.empty ()) { // a pilha é essencialmente funciona como informação de posição armazenados subproblems 
        P & lt = s.top (); 
        s.pop (); 
        G = s.top (); 
        s.pop (); 
        int privotIndex = partição (A, L, P & lt);
        se(privotIndex- 1 > l) { 
            s.push (l); 
            s.push (privotIndex - 1 ); 
        } 
        Se (privotIndex + 1 < r) { 
            s.push (privotIndex + 1 ); 
            s.push (r); 
        } 
    } 
}