algoritmus

[vajk fekete]

hu!

void quick_sort (element_t *table, int length)
{
  element_t temp, *left=table, *right=table+length-1;
  keytype reference_key = table[length/2].key;   /* for partitioning */

  do {                                           /* partitioning */
    while (left->key < reference_key)  left++;   /* search from left */
    while (reference_key < right->key) right--;  /* search from right */
    if (left <= right) {
      temp = *left;  *left++ = *right;  *right-- = temp;   /* swap, then ...*/
    }                                        /* ... bypass swapped elements */
  } while (left <= right);
  if (table<right)  quick_sort (table,right-table+1);
  if (left<table+length-1)  quick_sort(left,table+length-left);
}


Hat ez tokeletes pelda arra hogyan lehet a C sajatossagait kihasznalni olvashatatlan, 
karbantarthatatlan kod irasara.

pszeudobasic nyelven:

t[] amit rendezunk, indexei 0..length-1

ref = t[length/2]
left = 0
right = length-1

repeat
 while (t[left]<ref) do left=left+1 done
 while (ref < t[right]) do right=right-1 done
 if (left<=right) then 
  temp=t[left]
  t[left]=t[right]
  t[right=temp
  left=left+1
  right=right-1
 end if
until (left>right)
if (right>0) rendezzuk a tablanak a 0..right (inkluziv) tartomanyat end if
if (left<length) rendezzuk a tabla left..length tartomanyat

vajk

----- Original Message ----
From: vajk fekete <halaloszto at yahoo.co.uk>
To: elektro at tesla.hu
Sent: Thursday, 30 November, 2006 8:40:04 PM
Subject: Re: algoritmus

ott van az elejen angolul, az alapjan is le lehet kodolni.

roviden osszefoglalni megprobalom, bar jo regen csinaltam:

a rendezes: veszed a kozepso elemet. elolrol indulva keresel egyet, ami nem kisebb nala. hatulrol visszafele indulva keresel egyet, ami nem nagyobb nala. ha megvannak, megcsereled oket, majd az adott elso es masodik poziciobol folytatva a kereseseket megint talalsz es cserelsz. ezt addig amig a keresesek ossze nem ernek.

ha ezt a rendezest megcsinaltad az egeszre, akkor megcsinalod az elso felere es a masodik felere, aztan az elso negyedere, masodik negyedere, stb, amig a reszszakaszok amikre csinalod ketelemuve nem valnak. (lehet rekurzivan is: rendez, onmaga meghiv a ket felere ha azok legalabb ketelemuek)

tok szupi, mert helyben rendez, es a reszszakaszokra csinalva azok nagyon gyorsak, mert jo esellyel mar rendezettek, es az elore rendezett szakaszokon a kereses csak atszalad.

amugy vannak gyorsabb algoritmusok, csak sok hely kell hozzajuk! pl ha a 16 bites szamokat rendezel, es nincs kozottuk ismetlodes, akkor csinalsz egy 8kilobyte-os bitmezot, es egybe billented azokat a biteket amelyik szamok szerepelnek a rendezendo halmazban. aztan vegigmesz es kiolvasod oket sorban. mondjuk ha nincs ismetlodes es tobb mint 4000 szamod van, egy ilyen 8k-s mezoben kisebb helyen elfer a halmaz mint ha ketbyteon tarolva darabjat egy tombben tarolnad.

vajk

----- Original Message ----
From: Nagy Tibor <eltib at monornet.hu>
To: Papp Zoltán <elektro at tesla.hu>
Sent: Thursday, 30 November, 2006 8:23:05 PM
Subject: Re: algoritmus


> Pár rendezés C-ben: http://www.eet.bme.hu/infoc/SORTS.C (Pongor írta)

Na valami ilyesmi érdekelne folyamatábrában vagy basic, illetőleg pascal nyelven, mert a C az nálam teljesen ismeretlen. Mondjuk a bubble algoritmust megértettem belőle (mert ismerem), de a quick ebből a nyelvezetből nekem magas, ebből nem tudom átírni:(
Azért köszi!!

-- 
 tib

-----------------------------------------
          elektro[-flame|-etc]






Send instant messages to your online friends http://uk.messenger.yahoo.com 
-----------------------------------------
          elektro[-flame|-etc]






Send instant messages to your online friends http://uk.messenger.yahoo.com