Ďalšie zlepšenie triedenia výmenou, ktoré predstavuje najlepšiu metódu triedenia v poli, 
navrhol C.A.Hoare a nazval ju pre jej rýchlosť quicksort. Pod týmto názvom je metóda
všeobecne známa (viď funkcia qsort v jazyku C). Vychádza zo skutočnosti, že najefektívnejšie
 sú výmeny prvkov na čo najväčšie vzdialenosti. Triedenie preto (podobne ako shakersort) 
začína z oboch koncov poľa a končí, keď sa indexy stretnú. Funkcia quicksort využíva 
rekuzrívnu triediacu funkciu qs, ktorá zotrieďuje jednotlivé časti triedeného poľa. 
Použitie rekurzie je veľmi účinná programovacia technika [4], ktorá je v tomto prípade úplne 
namieste (niekedy však môže zapríčiniť aj nepríjemné situácie - doporučujeme zvýšenú 
obozretnosť !). 

/*   p10_1.c      triedenie
   metody
      bubblesort   priama vymena
      shakersort   pretriasanim
      insert        priamym vkladanim
      bininsert      binarnym vkladanim
      select       priamym vyberom
      Shellsort     vkladanim so
            zmensovanim kroku
      heapsort      stromove - haldou
      quicksort      rozdelovanim
      mergesort      priamym zlucovanim
   vyhladavanie
      binsearch   binarne hladanie
*/

#include <STDIO.H>
#include <ALLOC.H>

void bubblesort(int pole[], int pocet);
void shakersort(int pole[], int pocet);
void insert(int pole[], int pocet);
void insert1(int pole[], int pocet);
void bininsert(int pole[], int pocet);
void select(int pole[], int pocet);
void Shellsort(int pole[], int pocet);
void heapsort(int pole[], int pocet);
void quicksort(int pole[], int pocet);
void mergesort(int pole[], int pocet);
int binsearch(int pole[], int pocet, int cislo);

main()
{
 int a[32]={44,55,12,42,94,18,06,67,1,3,3,13,48,56,59,33},i;

printf("\nBegin\n");
for(i=0;i<16;i++)printf("%3d ",a[i]);
   insert(a,16);
   i=binsearch(a,16,12);
printf("\nResult 12 je a[%d]\n",i);
for(i=0;i<16;i++)printf("%3d ",a[i]);
   return 0;
}

void bubblesort(int pole[], int pocet)
/* bublinove triedenie - priamou vymenou   */
{
  int a,b,pom;

  for(a=1; a<POCET; b for(b="pocet-1;" ++a)>=a; --b)
     if(pole[b-1] > pole[b]){    /* vymena  */
      pom = pole[b-1];
      pole[b-1] = pole[b];
      pole[b] = pom;
      }
}

void shakersort(int pole[], int pocet)
/* triedenie pretriasanim - priamou vymenou   */
{
  int a,b,L,R,pom;

  L=1; R=b=pocet-1;
  do{
   for(a=R; a>=L; a--)
    if(pole[a-1] > pole[a]){
     pom = pole[a-1];
     pole[a-1] = pole[a];
     pole[a] = pom;
     b=a;       /* index vymeny lavy   */
     }
   L = b+1;
   for(a=L; a<R+1; if(pole[a-1] a++)> pole[a]){
     pom = pole[a-1];
     pole[a-1] = pole[a];
     pole[a] = pom;
     b=a;          /* index vymeny pravy   */
     }
   R = b-1;
   } while(L<=R);     /* kym sa nestretnu   */
}

void insert1(int pole[], int pocet)
/* triedenie priamym vkladanim   - verzia s kopiou */
{
  int a,b,pom,*ppole;

  ppole=malloc(pocet+1);    /* pom. pole   */
  for(a=0;a<POCET;A++) b="a;" while(b pom="ppole[a];" a++){ a<pocet; for(a="1;" a,b,pom,*ppole; int { * vkladanim priamym triedenie pocet) pole[], insert(int void } free(ppole); pole[a]="ppole[a+1];" }; vymena ppole[b]="ppole[b-1];" b--; ppole[b-1]){ < while(pom minimum 0 na ppole[0]="pom;" a<="pocet;" pocet po 1 od ppole[a+1]="pole[a];">0 && pom < pole[b-1]){
      pole[b] = pole[b-1];
      b--;
      }
   pole[b] = pom;      /* vymena   */
   };
}

void bininsert(int pole[], int pocet)
/* triedenie binarnym vkladanim      */
{
  int a,b,pom,m,L,R;

  for(a=1; a<POCET; for(b="a;b" pom="pole[a];" a++){ * } < R="a;" else L="0;" if(pole[m] m="(L+R)/2;" prvok pre miesto najst R){ while(L>=R+1;b--)  /* uvolnit miesto pre prvok */
     pole[b]=pole[b-1];
   pole[R]=pom;
   }
}

void select(int pole[], int pocet)
/* triedenie priamym vyberom      */
{
  int a,b,m,pom;

  for(a=0; a<POCET-1; for(b="a+1;b<pocet;" pom="pole[a];" a++){ int { * vkladanim triedenie pocet) pole[], void } pole[a]="pom;" }; vymena < m="a;" prvok for(m="t-1;" a,b,m,k,presun,pom,t="4,h[]={1,2,4,8};" Shell - kroku zmensovanim so Shellsort(int pole[m]="pole[a];" index a min. pom){ if(pole[b] b++)>=0; m--){     /* kroky spracovania   */
    k = h[m];
    do{
    presun = 0;         /* indikacia presunu   */
    for(a=k; a<POCET; b="a-k;" pom="pole[a];" a++){ * } pole[a]="pole[b];" }; kroku }while(presun presun="1;" pole[b]="pom;" v usporiad. porovnanie if(pom<pole[b]){>0);
    }
}

void heapsort(int pole[], int pocet)
/* stromove triedenie - haldou    */
{
  int L,R,pom,*ppole;
  void sift(int L, int R, int pole[]);

   ppole=malloc(pocet+1);    /* pom. pole   */
   for(L=0;L<POCET;L++) * pocet po 1 od R="pocet;" L="pocet/2+1;" while(L ppole[L+1]="pole[L];">1){           /* previerka prvkov   */
   L--;
   sift(L,R,ppole);
   };
   while(R>1){
   pom = ppole[1];
   ppole[1]=ppole[R];
   ppole[R]=pom;
   R--;
   sift(L,R,ppole);
   };
   for(L=0;L<POCET;L++) b="2*L;" pom="pole[L];" int { * void } free(ppole); L a="L;" if(pom b++; if(pole[b]<pole[b+1]) if(b<R) while(b<="R){" a,b,pom; haldy do prvku zaradenie pole[]) R, L, sift(int pole[L]="ppole[L+1];" spat pole>= pole[b])break;
     pole[a]=pole[b];
     a=b;
     b=2*a;
     }
   pole[a]=pom;
/*   getchar();
   printf("\nS L %d R %d\n",L,R);
   for(a=1;a<=16;a++)printf("%3d ",pole[a]);
*/
   }
void quicksort(int pole[], int pocet)
/* triedenie rozdelovanim - rekurzivne    */
{
  void qs(int L, int R, int pole[]);

  qs(0,pocet-1,pole);
}

void qs(int L, int R, int pole[])
/*   vlastna funkcia triedenia v poli - Hoare */
{
  int a,b,pom,pom1;

  a=L; b=R; pom=pole[(L+R)/2]; /* vyber prvku   */
  do{
   while((pole[a]<POM)&&(A<R)) while((pom<pole[b])&&(b a++;>L)) b--;
   if(a<=b){
     pom1=pole[a];
     pole[a]=pole[b];
     pole[b]=pom1;
     a++; b--;
     }
   }while(a<=b);
  if(L<B)QS(L,B,POLE); int { * triedenie pocet) pole[], void } pocet po 1 od m="pocet;" do pole if(up h="1;" ="1;" up="p" ppole[i+1]="pole[i];" 2*pocet az indexy for(i="0;i<pocet;i++)" pom. ppole="malloc(2*pocet+1);" i,j,k,L,t,h,m,p,q,r,up,*ppole; zlucovania priameho metodou mergesort(int if(a<R)qs(a,R,pole);>0) {    /* zdroj 1. cast   */
   i=1; j=pocet;
   k=pocet+1; L=2*pocet;
   }
   else{         /* zdroj 2. cast   */
   k=1; L=pocet;
   i=pocet+1; j=2*pocet;
   };
   /* zlucit postupnosti, urcene indexami i,j
   do postupnosti urcenej indexom k;
   q je dlzka i-postupnosti, r j-postupnosti */
   do {
   if(m>=p) q=p;
   else q=m;
   m=m-q;
   if(m>=p) r=p;
   else r=m;
   m=m-r;
   while((q!=0)&&(r!=0)){   /* zlucovanie   */
     if(ppole[i]<PPOLE[J]){ } }; while(r r--; j--; k="k+h;" ppole[k]="ppole[i];" else{ q--; i++;>0){   /* kopia zvysku j postupnosti */
      ppole[k]=ppole[j]; k=k+h;
      j--; r--;
      };
   while(q>0){   /* kopia zvysku i postupnosti */
      ppole[k]=ppole[i]; k=k+h;
      i++; q--;
      };
   h=-h; t=k;
   k=L; L=t;
   } while(m!=0);
   up=-up; p=2*p;
   } while(p<POCET); b="pom-1;" pom="(a+b)/2;" int { * pole[], } free(ppole); else - a="0;b=pocet-1;" a,b,pom; prvku pole[L]="ppole[L+1];" spat pole for(i="0;i<pocet;i++)" if(cislo if(cislo<pole[pom]) while(a<="b){" !!! zotriedene usporiadane byt musi intervalu delenim cislo hladanie binarne cislo) pocet, binsearch9int for(L="0;L<pocet;L++)" ppole[i]="ppole[i+pocet];" if(up<0)>pole[pom])
      a=pom+1;
    else     /* index prvku */
      return pom;
    }
   return(-1);    /* nenaslo sa */