BitCell

by **Cosmin_NTG** » 01 Aug 2011, 21:18

Quicksort

-Tutorial-

Acest tutorial este destinat tuturor celor ce vor sa aprofundeze cunostintele legate de algoritmii de sortare prin imbogatirea acestora cu un algoritm pe cat de simplu, pe atat de eficient (quicksort).

Cunoscuta si sub numele de sortarea prin partitionare, quicksort este o metoda de sortare rapida, de unde deriva si numele.

Cu o complexitate medie de O(n log n), quicksort este alegerea optima de fiecare data cand se intalnesc probleme de sortare.
Algoritmul metodei imbina caracterul simplist cu performantele, ceea ce denota atat o usoara intelegere a algoritmului cat si performante destul de mari.

Pentru inceput, vom analiza aproximativ linie cu linie urmatorul cod in limbajul de programare C++:

Line number On/Off | Expand/Contract | Select all

void quicksort(int v[100], int stanga, int dreapta)
{
   int i, j, mijloc, aux;         // variabilele
   i=stanga;                       //  initializarea 
   j=dreapta;                    //   indicilor
   mijloc=v[(stanga+dreapta)/2];  // initializarea variabilei - pivot 
  while(i<=j)
  {
   while(v[i]<mijloc)  // apropierea i-ului de mijloc
      i++;
   while(v[j]>mijloc)   // apropierea j-ului de mijloc
      j--;
    if(i<=j)   //conditia efectuarii operatiei de interschimbare
    {
       aux=v[i];
       v[i]=v[j];   // operatia de interschimbare
       v[j]=aux;
       i++;
       j--;
     }
  }                     
 if(stanga<j)                    //recursivitatea            
   quicksort(v, stanga, j);   // in partea stanga     
 if(i<dreapta)                     
   quicksort(v, i, dreapta);  // in partea dreapta
 
}

Aceasta functie este implementarea in C++ a algoritmului metodei de sortare quicksort.

Line number On/Off | Expand/Contract | Select all

void quicksort(int v[100], int stanga, int dreapta)

Aceasta linie reprezinta antetul functiei. Dupa cum se observa, functia este declarata void pentru ca
nu trebuie sa intoarca nici un rezultat, ci doar sa modifice pozitia elementelor din vector.
Functia primeste 3 parametri: primul este vectorul ce trebuie sortat, al doilea este un numar ce reprezinta indexul primului element din vector (cel din stanga) iar al treilea este, de asemenea, un numar ce reprezinta indexul ultimului element din vector (cel din dreapta).

Line number On/Off | Expand/Contract | Select all

int i, j, mijloc, aux;

Pentru a parcurge algoritmul, sunt necesare 4 variabile: o variabila ( i ) cu rolul de a parcurge vectorul (vorbind la modul general) spre dreapta prin incrementare ( i + + ); o variabila ( j ) cu rolul de a parcurge vectorul spre stanga prin decrementare ( j - - ); o variabila (mijloc) cu rolul de pivot, mai exact cu rolul de a partitiona, de a imparti vectorul in parti mai mici ce urmeaza a fi sortate ulterior si o variabila auxiliara ( aux ) cu rolul de a pastra temporar valorile elementelor ce vor interveni in operatia de interschimbare.

Line number On/Off | Expand/Contract | Select all

i=stanga;
j=dreapta;

In aceste doua operatii, variabilele i si j sunt initializate cu valorile parametrilor primiti de functie "stanga" respectiv "dreapta".
Motivul pentru care in algoritm nu sunt utilizati parametrii in mod direct (in loc de variabilele i si j) este reprezentat de faza recursiva a algoritmului unde valorile initiale ale parametrilor amintiti mai sus sunt indispensabile.

Line number On/Off | Expand/Contract | Select all

mijloc=v[(left+right)/2];

Aceasta linie reprezinta initializarea variabilei - pivot cu o valoare apropiata de mijlocul vectorului (nu trebuie neaparat sa fie exact mijlocul). Aceasta valoare va deveni o valoare - reper in operatia de parcurgere a vectorului.

Line number On/Off | Expand/Contract | Select all

 while(i<=j)

Algoritmul este structurat in 3 instructiuni repetitive cu numar necunoscut de pasi si cu test initial (while). Prima structura este una de ansamblu in care se afla celelalte doua plus operatia de interschimbare. Aceasta structura de ansamblu are rolul de a "monitoriza" pozitia indicilor (i si j) si de a participa la partitionarea vectorului.

Line number On/Off | Expand/Contract | Select all

 while(v[i]<mijloc)
     i++;
while(v[j]>mijloc)
     j--;

Urmatoarele doua instructiuni repetitive au rolul de a apropia indicii de variabila - pivot aflata aproape de mijlocul vectorului.
Prima instructiune apropie i-ul de mijloc iar a doua apropie j-ul. Aceste doua instructiuni participa constructiv la eficientizarea algoritmului din punct de vedere al timpului de executie.

Line number On/Off | Expand/Contract | Select all

if(i<=j)
{
     aux=v[i];
     v[i]=v[j];
     v[j]=aux;
     i++;
     j--;
}

Aceasta bucata de cod reprezinta operatia de interschimbare. Este mai degraba o operatie mai complexa dat fiind faptul ca este compusa din mai multe operatii de atribuire. Rolul acesteia este acela de interschimba valorile elementelor vectorului atunci cand cele doua instructiuni repetitive pozitionate inaintea acestei operatii permit acest lucru.

Line number On/Off | Expand/Contract | Select all

if(stanga<j)
     quicksort(v, stanga, j);
if(i<dreapta)
     quicksort(v, i, dreapta);

Algoritmul se incheie, dupa cum se observa cu doua instructiuni conditionale ce verifica daca valorile indicilor rezultate dupa operatiile din cadrul algoritmului se incadreaza in partile corespunzatoare lor din vector (i-ul va trece in dreapta prin incrementare, deci trebuie sa fie mai mic decat parametrul initial "dreapta" primit de functie, iar j-ul trece in stanga prin decrementare, deci trebuie sa fie mai mare decat parametrul "stanga" primit initial de functie ).

Pentru a va ajuta sa intelegeti mai bine algoritmul, am creat urmatoarele diagrame sugestive ce reprezinta pozitia si valoarea variabilelor implicate direct in algoritm la fiecare parcurgere:

In acest pas ne aflam in momentul in care vectorul este nesortat inainte de inceperea primei parcurgeri.

Pasul 2 reprezentat in imaginea de mai sus descrie apropierea de mijloc a celor doi indici i si j asta insemnand mai exact parcurgerea celor doua while-uri pozitionate inaintea operatiei de interschimbare.
Explicatie:

Dupa cum am vazut in primul pas, mijlocul ia valoarea v[(stanga + dreapta)/2] ceea ce inseamna v[ (0 + 6)/2] adica v[3] care este egal cu 3.
La intrarea in primul while despre care am vorbit mai sus (cel care incrementeaza i - ul), valoarea lui i este 0 (zero) iar conditia instructiunii repetitive ( v[0]<mijloc ) nu este indeplinita deoarece v[0]=4 care este mai mare decat 3 (mijlocul) prin urmare, primul while nu este parcurs. De aceea in pasul 2 ( pasul de fata ) i - ul ramane 0 (zero) pentru ca nu se incrementeaza.
In mod analog, la intrarea in al doilea while se observa ca v[ j ] > mijloc ceea ce permite parcurgerea instructiunii ( adica decrementarea j -ului) insa parcurgerea are loc doar o singura data pentru ca dupa decrementare, j-ul devine 5 iar v[5] = 2 care este mai mic decat 3 deci conditia nu mai este indeplinita.

Imaginea de mai sus este destul de sugestiva. Dupa o scurta analiza a pasului 2 de mai sus, se observa ca i-ul este 0 (zero) iar j-ul 5. Acest lucru satisface conditia necesara efectuarii operatiei de interschimbare. Prin urmare, are loc interschimbarea intre v[ 0] si v[ 5 ].

In iteratia 1, primul pas este reprezentat de cele doua while-uri (exact ca in pasul 1 al parcurgerii initiale). Valoarea lui i este 1 pentru ca s-a incrementat in operatia de interschimbare din parcurgerea precedenta iar v[1] nu este mai mic decat variabila mijloc ( 6 > 3 ) deci nu se incrementeaza. Pe de alta parte, j-ul fiind decrementat din operatia de interschimbare se decrementeaza din nou, v[j] fiind mai mare decat variabila mijloc ( 5 > 3 ).

Operatia de interschimbare din iteratia 1.

Primul pas din iteratia a doua impune nerespectarea ( i > j ) a doua conditii identice: cea a instructiunii repetitive de ansamblu si cea a operatiei de interschimbare.

Dupa cum clar se observa, vectorul s-a impartit in doua, lucru impus de recursivitate. Imediat ce i-ul depaseste valoare j-ului, in vector se individualizeaza doua parti: prima este marginita de parametrul initial primit de functie (stanga) si de j (care s-a decrementat ) iar a doua parte este marginita de i (care s-a incrementat) si de celalalt parametru primit initial de functie (dreapta). In final, apelarea functiei prin parametrii ce marginesc cele doua parti, fac posibila sortarea integrala a vectorului de unde si numele de sortare prin partitionare . Urmarorii pasi sunt exact cei descrisi mai sus, aplicatii separat pe cele doua partitii formate.
In final, vectorul sortat va avea forma:

Pentru a va ajuta sa intelegeti mai bine algoritmul quicksort, va recomand urmatorul program:
http://www.cs.oswego.edu/~mohammad/classes/csc241/samples/sort/Sort2-E.html
Se numeste "Sort Animation" si este un program structurat destul de inteligent: In partea stanga este algoritmul (functia in C++) unde fiecare linie este colorata in momentul cand programul o parcurge iar in partea dreapta se afla vectorul cu pozitia fiecarui element si valoarea tuturor variabilelor din program. Exista optiuni de setare a vitezei de parcurgere a algoritmului cat si de schimbare a acestuia cu alte 3 metode de sortare cunoscute

Sper ca m-am facut inteles. Spor la invatat !
Cosmin_NTG

by **morpheus** » 02 Aug 2011, 01:20

Pentru variatie, o implementare C folosind algoritm de partitionare Lomuto si median of three:

Line number On/Off | Expand/Contract | Select all

 
#include <stdio.h>
 
#define SWAP(x, y, type)  \
do                        \
{                         \
    type __temp = x;      \
    x = y;                \
    y = __temp;           \
} while(0);
 
#define PARTITION_MEDIAN_OF_THREE(a, first, last, pivot, type)   \
do                                                               \
{                                                                \
    type __first = first;                                        \
    type __last = last;                                          \
    type __mid = __first + (__last - __first) / 2;               \
    type __pivot = a[__first] > a[__mid] ? __first : __mid;      \
    if (a[__pivot] > a[__last])                                  \
        __pivot = __last;                                        \
    SWAP(a[__pivot], a[__first], type);                          \
    __pivot = __first;                                           \
    while (__first < __last)                                     \
    {                                                            \
        if (a[__first] <= a[__last])                             \
        {                                                        \
            SWAP(a[__pivot], a[__first], type);                  \
            ++__pivot;                                           \
        }                                                        \
        ++__first;                                               \
    }                                                            \
    SWAP(a[__pivot], a[__last], type);                           \
    pivot = __pivot;                                             \
}                                                                \
while(0);
 
 
void quicksort(int a[], int first, int last)
{
    if (first < last) 
    {
        int pivot;
        PARTITION_MEDIAN_OF_THREE(a, first, last, pivot, int);
        quicksort(a, first, pivot - 1);
        quicksort(a, pivot + 1, last);
    }
}
 
void display(int a[], size_t size)
{
    int i;
    for (i = 0; i < size; ++i)
        printf("%d\n", a[i]);
}
 
int main()
{
    int a[] = {9,8,6,7,0,1,2,4,5,3};
    printf("Before sorting:\n");
    display(a, 10);
    quicksort(a, 0, 9);
    printf("After sorting:\n");
    display(a, 10);  
    return 0;
}
 

PS: ^poti sa demonstrezi ca Quicksort e O(n^2) in cazul cel mai defavorabil si O(n * log n) in medie ?
Eventual, discuta si despre stabilitate.

by **Cosmin_NTG** » 02 Aug 2011, 12:38

Intr-adevar nu pot demonstra acest lucru (si nici nu vreau sa aberez o demonstratie cu niste lucruri neintelese de pe net) pentru ca imi trebuie cunostinte despre logaritmi, combinari and stuff care se fac in clasa a 10-a iar eu abia am trecut a 10-a. Eu stiam (stiu) ca motivul pentru care complexitatea este de O(n log n) il reprezinta faptul ca se executa n log n operatii. De aceea este o complexitate medie. Dar nu vreau sa aberez, cum am spus mai sus. Mi s-a parut important acest aspect al complexitatii si de aceea l-am si punctat in tutorial insa astfel de demonstratii ma cam depasesc (pentru moment >:)

) .

by **cata45** » 06 Aug 2011, 15:28

Incerc sa folosesc QS pentru a sorta niste coordonate.
Ceva de genul:

Line number On/Off | Expand/Contract | Select all

Algoritmul construit de mine le sorteaza doar dupa x. In cazul de mai sus raman exact lafel. Cum as putea sa le sortez si dupa x si dupa y? (adica daca x-si sunt egali sa ordoneze in functie de y) Pe exemplul de mai sus sa rezulte:

Line number On/Off | Expand/Contract | Select all

Codul scris de mine arata asa:

Line number On/Off | Expand/Contract | Select all

 
void QS(unsigned short stanga, unsigned short dreapta) 
{
    unsigned short i, j, aux, m;
    i=stanga; 
    j=dreapta; 
    m=mijloc[stanga+(dreapta-stanga)/2].x;
    //folosesc o structura mijloc 
    while(i<=j) 
    {
        while(mijloc[i].x<m)
            i++;
        while(mijloc[j].x>m)
            j--;
        
        if(i<=j)
        {
            aux = mijloc[i].x;
            mijloc[i].x = mijloc[j].x;
            mijloc[j].x = aux; 
            aux = mijloc[i].y;
            mijloc[i].y = mijloc[j].y;
            mijloc[j].y = aux; 
            i++; 
            j--;
        }
    } 
    
    if(stanga<j)
        QS(stanga, j);
    
    if(i<dreapta)
        QS(i,dreapta);
}
 

Folosesc in cadrul programului o structura numita mijloc pentru coordonatele mijlocului unui segment (mijloc[i].x si mijloc[i].y reprezinta coordonatele mijocului segmentului i)

L.E. (-- 06 Aug 2011, 12:36 --)

Am gasit o rezolvare la problema mea(mai neortodoxa...dar functioneaza) ..dupa ce am ordonat cu QS toate coordonatele in functie de x am folosit un QS pentru a ordona toate secventele cu x-ul egal in functie de y.

Dar totusi ma intereseaza cum as putea sa fac sa le ordonez intr-un singur QS...

by **eni4ever** » 09 Aug 2011, 10:12

^ Două operațiuni de sortare reprezintă o soluție foarte ineficientă dpdv al timpului de execuție. Ai putea încerca o abordare ce presupune o preprocesare apriori a vectorului de elemente.
Considerăm că un element (punct) are următoarea structură:

Line number On/Off | Expand/Contract | Select all

struct element{
  int pondere;
  char x[10];
  char y[10];
};

unde cel mai important câmp ar fi ponderea. Aceasta am încărca-o din următoarea observație :
Fie

Line number On/Off | Expand/Contract | Select all

element1.x element1.y
element2.x element2.y
...
elementn.x elementn.y

rezultatul final al operațiunii de sortare $\rightarrow \forall i\in[1,n]$ și $j\in[1,n]$ cu $i<j$ avem $(element[i].x|element[i].y) < (element[j].x|element[j].y)$ unde cu $(a|b)$ s-a notat concatenarea numerică (ponderea) celor 2 dimensiuni.
Datorită naturii numerice a celor 2 dimensiuni, ponderea ar deveni o valoare algebrică calculată din expresia : $(a|b) = a*10^{numarcifre(b)} + b$ . Astfel, pentru un element oarecare i, ponderea atribuită devine $element[i].pondere = element[i].x*10^{nrcifre(element[i].y)} + element[i].y$ .
Astfel, noul câmp conferă posibilitatea de a realiza sortarea coordonatelor după o singură dimensiune realizându-se în fond o singură parcurgere a vectorului de elemete.

Să luăm un exemplu practic. Presupunem că datele de intrare ar fi dintr-o plajă extinsă de semne atât pentru x cât și pentru y :

1 2
-3 5
7 -1
10 19
1 7
-1 -2

.Ponderea calculată pentru fiecare punct ar fi :

12
-25
69
1019
17
-12

.Sortarea elementelor după aceste ponderi ar produce următoarea secvență :

-25
-12
12
17
69
1019

, iar maparea lor pe structura de coordonate inițiale ne-ar oferi rezultatul final :

-3 5
-1 -2
1 2
1 7
7 -1
10 19

. Acest rezultat este, după cum se poate observa, întradevăr o sortare dupa x și y a coordonatelor.

Temă

: Realizează o sortare dupa y și x.

Spor

by **cata45** » 09 Aug 2011, 13:45

Multumes mult de raspuns. Ma gandisem la o concatenare dar ma incurcau mult semnele. Oricum se incadra in timp si solutia mea cu doua sortari (sunt constient ca asta e mult mai buna ...dar la momentul ala trebuia sa fac ceva) Ty again.

Sortare dupa y si x:

Line number On/Off | Expand/Contract | Select all

 
//#include<fstream>
#include<iostream>
using namespace std;
/*
#define IN "pondere.in"
#define OUT "pondere.out"
fstream f(IN, ios::in), g(OUT, ios::out);
*/
int i, n;
struct A{
    long long pondere;
    int x;
    int y;
}point[1000];
int nrcifre(int x)
{
    int nr=0;
    while(x)
    {
        x=x/10;
        nr++;
    }
    return nr;
}
int power(int a)
{
    int i;
    long long result=1;
    for(i=1; i<=a; i++)
        result*=10;
    return result;
}
void QS(int stanga, int dreapta)
{
    int i, j, aux, mijloc;
    i=stanga;
    j=dreapta;
    mijloc=point[stanga+(dreapta-stanga)/2].pondere;
    while(i<=j)
    {
        while(point[i].pondere<mijloc)
            i++;
        while(point[j].pondere>mijloc)
            j--;
        if(i<=j)
        {
            aux=point[i].pondere;
            point[i].pondere=point[j].pondere;
            point[j].pondere=aux;
            
            aux=point[i].x;
            point[i].x=point[j].x;
            point[j].x=aux;
            
            aux=point[i].y;
            point[i].y=point[j].y;
            point[j].y=aux;
            
            i++;
            j--;
        }
    }
    if(stanga<j)
        QS(stanga, j);
    if(dreapta>i)
        QS(i, dreapta);
}
int main()
{
    //f>>n;
    cout<<"n="; cin>>n;
    for(i=1; i<=n; i++)
    {
        //f>>point[i].x>>point[i].y;
        cout<<"Coordonate punct "<<i<<" sub forma x y: ";
        cin>>point[i].x>>point[i].y;
        point[i].pondere=point[i].y*power(nrcifre(point[i].x))+point[i].x;
    }
    
    QS(1,n);
    
    cout<<"\n\nORDONARE DUPA Y\n";
    cout<<"===============================================\n";
    for(i=1; i<=n; i++)
        //g<<point[i].x<<" "<<point[i].y<<" "<<point[i].pondere<<'\n';
        cout<<point[i].x<<" "<<point[i].y<<"\n";
}
    
 

Merge pe coordonate mai "mititele". Pentru coordonate care se apropie de 264este necesar sa folosesc siruri de caractere. Le concatenez si pentru ordonare folosesc strcmp(sirA,sirB); Multumesc inca o data de idee. %%-

by **morpheus** » 10 Aug 2011, 12:33

Nu e bine ce faci. Nu respecti un principiu de baza al designului software, care spune sa separi ceea ce difera de ceea ce ramane la fel.
Ceea ce ramane la fel este logica algoritmului. Ceea ce difera e natura datelor de intrare (ce se vor sortate) si criteriul de comparatie intre elemente apartinand datele de intrare.
Mai precis, algoritmul de sortare ar trebui sa indeplineasca doua conditii:
1. sa nu depinda de tipul datelor de intrare. Initial, algoritmul sorta array-uri de numere intregi. Tu l-ai rescris sa sorteze structuri de tip A. Nu e bine ca l-ai rescris, trebuia sa fie suficient de flexibil ca sa nu depinda de tipul datelor.
2. sa nu depinda de criteriul de comparatie
Tu ai rescris algoritmul folosind un criteriu de comparatie (dubios), hardcoded in mijlocul algoritmului. Solutia uzuala este sa folosesti un pointer la functie (in C) sau un functor (in c++).
Uita-te la prototipul functiei qsort si la algoritmii sort din STL.

Solutia normala, in C++:
1. Algoritmul sa opereze pe o secventa de elemente, specificata cu ajutorul a doi iteratori (de inceput si de sfarsit).
Tipul iteratorului este generic, specificat printr-un parametru template. Astfel decuplezi logica algortimului de tipul concret de date pe care opereaza
2. Algoritmul sa abstractizeze comparatia elementelor folosind un functor (tot ca parametru template)
Astfel abstractizezi criteriul de comparatie intre elementele secventei, ce va fi folosit in procesul de sortare.

Ceva de genul:

Line number On/Off | Expand/Contract | Select all

 
#include <iostream>
#include <algorithm>
#include <iterator>
#include <functional>
 
template<typename RandomAccessIterator, typename StrictWeakOrdering>
inline RandomAccessIterator ChoosePivot(RandomAccessIterator begin,
    RandomAccessIterator end,
    StrictWeakOrdering comp)
{
    RandomAccessIterator pivot(begin + std::distance(begin, end) / 2);
    if(!comp(*pivot, *begin) && !comp(*begin, *(end - 1)))
        pivot = begin;
    else if(!comp(*pivot, *(end-1)) && !comp(*(end - 1), *begin))
        pivot = end - 1;
    return pivot;
}
 
template<typename RandomAccessIterator, typename StrictWeakOrdering>
RandomAccessIterator Partition(RandomAccessIterator begin,
    RandomAccessIterator end,
    StrictWeakOrdering comp)
{
    RandomAccessIterator pivot = ChoosePivot(begin, end, comp);
    typename std::iterator_traits<RandomAccessIterator>::value_type pivotValue(*pivot);
    std::iter_swap(pivot, end-1);
    RandomAccessIterator store = begin;
    for(RandomAccessIterator it = begin; it != end - 1; ++it) {
        if(!comp(pivotValue, *it)) {
            std::iter_swap(store, it);
            ++store;
        }
    }
    std::iter_swap(end - 1, store);
    return store;
}
 
template<typename RandomAccessIterator, typename StrictWeakOrdering>
void QuickSort(RandomAccessIterator begin,
    RandomAccessIterator end,
    StrictWeakOrdering comp)
{
    if((end - begin) > 1) {
        RandomAccessIterator pivot = Partition(begin, end, comp);
        QuickSort(begin, pivot, comp);
        QuickSort(pivot + 1, end, comp);
    }
}
 
struct Interval
{
    int x;
    int y;
};
 
struct Comparator : public std::binary_function<Interval, Interval, bool>
{
    bool operator() (const Interval& a, const Interval& b)
    {
        if (a.x != b.x)
            return a.x < b.x;
        else
            return a.y < b.y;
    }
};
 
void PrintIntervalsArray(Interval intervals[], size_t count)
{
    for (size_t i = 0; i < count; ++i)
        std::cout << "x=" << intervals[i].x << ",y=" << intervals[i].y << "\n";
}
 
int main()
{
    Interval intervals[] =
    {
        {1, 2},
        {-3, 5},
        {7, -1},
        {10, 19},
        {1, 7},
        {-1, -2},
        {-3, 6},
        {9, 2},
        {10, 1},
        {9, 1},
        {8, 6}
    };
    const size_t intervalsCount = sizeof(intervals) / sizeof(Interval);
    std::cout << "Before sorting \n";
    PrintIntervalsArray(intervals, intervalsCount);
    QuickSort(intervals, intervals + intervalsCount, Comparator());
    std::cout << "After sorting \n";
    PrintIntervalsArray(intervals, intervalsCount);
   
    int arr[] = {9,7,1,5,8,9,3,10,0,0,1,0,1,3,4};
    const size_t arrCount = sizeof(arr) / sizeof(int);
    std::cout << "Before sorting \n";
    std::copy(arr, arr + arrCount, std::ostream_iterator<int>(std::cout, " "));
    std::cout << "\n";
    QuickSort(arr, arr + arrCount, std::less<int>());
    std::cout << "After sorting \n";
    std::copy(arr, arr + arrCount, std::ostream_iterator<int>(std::cout, " "));
    std::cout << "\n";
   
    return 0;
}
 

Poti incerca, ca si exercititu, o implementare C, in care abstractizezi tipul datelor de intrare folosind pointeri la void si criteriul de comparatie folosind un pointer la functie.

BitCell

Quicksort

Quicksort

Re: Quicksort

Re: Quicksort

Re: Quicksort

Re: Quicksort

Re: Quicksort

Re: Quicksort

Who is online