Algoritmusok és adatszerkezetek gyakorlat 09 Rendezések

Átírás

1 Algortmusok és adatszerkezetek gyakorlat 09 Rendezések Néhány órával ezelőtt megsmerkedtünk már a Merge Sort rendező algortmussal. A Merge Sort-ról tuduk, hogy a legrosszabb eset dőgénye O(n log n). Tetszőleges (általános célú) rendezőalgortmusra a elenleg legobb dőgény alsó korláta Ω(n log n). Felmerülhet a kérdés, hogy ha a Merge Sort dőgénye éppen enny, mért léteznek más algortmusok s. Eddg csak az dőgénnyel foglalkoztunk, vszont a rendezőalgortmusok tárgénye elég eltérőek lehetnek. Merge Sort Algortmus: MERGESORT (A[1,..., n]) 1. Ha n = 1 return A. Rekurzívan alkalmazzuk a lsta két felére: MERGESORT (A[1,..., n/ ]) és MERGESORT (A[ n/ + 1,..., n]). A lstát,,fésülük össze Időgény: O(n log n) (legrosszabb, legobb és átlagos esetben s) Tárgény: O(n) plusz tárat gényel, ha az adathalmazt tömbben tároluk (ugyanannyt, mnt a rendezendő nput elemszáma) ezért nagy elemszámú tömbben tárolt nputhoz nem aánlott a használata A lehető legobb választás, ha láncolt lstát kell rendezn, mert ekkor csak O(1) a plusz tárgény Stabl rendezés, am azt elent, hogy az nputban két egyenlő elem eredet egymáshoz képest sorrende megmarad a rendezés után s Quck Sort Paradgma: Dvde & Conquer 1. Dvde: Osszuk fel a tömböt két résztömbre egy x pvot elem szernt a következőképpen: azok az elemek, amk ksebb egyenlőek a pvotnál legyenek előtte, amk nagyobb egyenlőek nála, legyenek utána.(a pvottal egyenlő elemek bármelyk résztömbbe kerülhetnek.) x x x. Conquer: Rekurzívan rendezzük a két résztömböt.. Combne: Trváls. 1 Gelle Ktt

2 Algortmus: QuckSort (A, p, r ) P a r t t o n (A, p, q ) f ( p < r ) x=a[ p ] q = P a r t t o n (A, p, r ) =p QuckSort (A, p, q 1) := r QuckSort (A, q+1, r ) whle ( true ){ whle (A[ ]>=x&&(< ) ) := 1 whle (A[ ]<=x&&(< ) ) := +1 f ( <= ) break e l s e c s e r e (A[ ],A[ ] ) } c s e r e (A[ p ],A[ ] ) return Meghívása: QuckSort(A, 1, n) Időgény: O(n ) (legrosszabb eset), O(n log n) (legobb és átlagos eset) Tárgény: O(log n) plusz tárat gényel Nem stabl rendezés A gyakorlatban általában kétszer olyan gyors, mnt a Merge Sort Countng Sort Akkor használuk, ha a tömbben legfelebb k-féle érték szerepel Algortmus: CountngSort(A[1,..., n], k) 1. Hozzunk létre egy k elemű tömböt és számoluk bele össze, melyk elemből menny van. Módosítsuk úgy az értékeket, hogy mnden tömbelem az őt megelőzőek összegét tartalmazza. Tegyünk mnden nput elemet a helyére a kmenetben úgy, hogy véggmegyünk az nputon és a segédben található ndexre tesszük, mad növelük a számlálóát Időgény: O(n + k). Akkor érdemes használn, ha k = O(n), mert akkor a futásdő O(n) Tárgény: O(n + k) Stabl rendezés Külső rendezés Gelle Ktt

3 1. Feladat Rendezzük az,, 9, 17, 77, 1,,, 0 elemeket tartalmazó tömböt a QuckSort algortmussal. Megoldás swap swap swap swap swap swap 0 Gelle Ktt

4 . Feladat Rendezzük a,,, 1,,, 1, elemekből álló tömböt Leszámláló rendezéssel. Megoldás In: 1 1 Gyűtsük össze, mből menny van. A paraméterek: n = és k =. Vegyünk fel segédnek egy k + 1 elemű tömböt. f o r x n nput : count [ key ( x ) ] += 1 C: Módosítsuk úgy az értékeket, hogy mnden elem a nála <-ek összegét tartalmazza (prefxösszeg tömbbé alakítás): t o t a l = 0 f o r n range ( k+1): // = 0, 1,... k oldcount = count [ ] count [ ] = t o t a l t o t a l += oldcount C: Haladunk végg az nputon és rakuk arra az ndexre, ahol a segédtömbben szerepel, mad növelük a számláló értékét. f o r x n nput : output [ count [ key ( x ) ] ] = x count [ key ( x ) ] += 1 In: 1 1 In: 1 1 C: C: C[1] + + C[] + + C[] + + C[] + + Out: 1 C[1] + + C[] + + C[] + + C[] + + Out: 1 1 Gelle Ktt

5 A Countng sort O(n + k) dőgénnyel alkalmazható láncolt lsták esetén s úgy, hogy a leszámláláshoz ettől függetlenül tömböt használunk. Ktereszthető olyan ntervallumokra s, amkor nem 0 az alsó értékhatár. módosítanánk a 0-tól eltérő alsó határ kezelésére az algortmust? Hogyan Bnárs kupac Bnárs fa: Olyan fa, ahol mnden csúcsnak legfelebb gyereke van Bnárs kupac: madnem teles bnárs fa, amely mnden szntén telesen ktöltött kvéve a legalacsonyabb szntet, ahol balról obbra haladva egy adott csúcsg vannak elemek A fát egy tömbben reprezentáluk, mnden elem a sznt szernt beárás szernt sorszámának megfelelő eleme a tömbnek. A kupacot reprezentáló A tömbhöz két értéket rendelünk: hossz(a) a tömb mérete, kupacmeret(a) a kupac elemenek száma. A kupac gyökere A[0], a szerkezet kapcsolatok egyszerűen számolhatóak: A[] bal fa A[ + 1] A[] obb fa A[ + ] A[] apa A[ ( 1)/ ] A kupac mnden gyökértől különböző elemére telesül, hogy az értéke nem lehet nagyobb, mnt az apáé. Ennek következménye, hogy a kupac mnden részfáára telesül, hogy a gyökéreleme maxmáls. Heap Sort Algortmus: HeapSort(A[1,..., n]) 1. Építsünk egy maxmum kupacot az nputból. Ekkor a legnagyobb elem a kupac gyökerében van. Cserélük ezt k a kupac utolsó elemével, és hívuk meg az elárást az eggyel ksebb méretű kupacra. Ha a kupactuladonság sérül az ú gyökér matt, állítsuk helyre.. Ismételük a fent lépéseket, amíg a kupac mérete nem lesz 1 Időgény: O(n log n) Tárgény: O(1) Nem stabl rendezés Helyben rendez Gelle Ktt

6 . Feladat Rendezzük Heap sort algortmussal az A = [, 1,,,,,, ] tömböt! Megoldás Rendezzük kupacba: Építsük meg a fát. Az A[0] lesz a gyökér. A két fa az A[ 0+1] = A[1] = 1 és A[ 0+] = A[] = és így tovább. Pl a 1 gyereke lesznek az A[ 1+1] = A[] = és A[ + ] = A[] =. Mad állítsuk helyre a kupactuladonságot a legalsó részfáktól kezdve. Paraméterek: hossz(a) = és kupacmeret(a) =. Kupactuladonság helyreállítása: Hasonlítsuk össze a gyökér és a két gyereke értékét Ha a gyökér értéke a legnagyobb, nncs tovább dolgunk Ha közülük a legnagyobb a obb gyerek értéke, akkor cserélük meg a gyökér és a obb gyerek értékét, mad rekurzívan állítsuk helyre a obb részfát Ha a bal gyerek értéke a legnagyobb, cserélük vele, mad rekurzívan állítsuk helyre a bal részfát A kapott kupacban mnden részfa telesítette a kupactuladonságot (hogy a részfáában a gyökér a legnagyobb értékű csúcs). Egyedül a gyökérben lévő elem sértette meg. Ezután a kupac gyökerét cserélük k a kupac utolsó elemével. Így a legnagyobb elem a helyére kerül a tömbben. Törölük a kupac utolsó elemét. Csökkentsük a kupac méretét eggyel, és állítsuk helyre a kupactuladonságot az ú kupacunkban. kupacmeret(a) = Gelle Ktt

7 Rakuk a tömbben a helyére a -at, törölük a kupacból. kupacmeret(a) =. Állítsuk helyre a kupactuladonságot Gelle Ktt

8 . Feladat Döntsd el, melyk rendezőalgortmust használnád, ha az alábbakat tudod: 1. Egy tömb elemű és között elemeket tartalmaz.. Egy tömb elemű és között elemeket tartalmaz és helyben szeretnénk rendezn.. Egy láncolt lsta elemet tartalmaz. Az elemek ntervallumáról nem tudunk semmt.. Egy tömb 1000 elemet tartalmaz és az elemek ntervalluma [ 00000, 00000]. Egy tömb elemet tartalmaz, az elemek ntervallumáról nncs nformácónk, vszont fontos, hogy a megegyező elemek az eredet sorrendükhöz képest ne változzanak a rendezett lstában. Egy láncolt lsta 1000 elemet tartalmaz. A tárolt adatok ntervalluma [ 10, 10]. A választ ndokold! Megoldás 1. Mvel a tömb méretéhez képest a benne tárolt elemek ntervalluma kcs, Countng sort-ot érdemes használn. Az előbb szntén gaz, de a Countng sort külső rendezés. Tömbökön ól működk például egy Quck sort.. Mvel a tárolt elemekről semmt nem tudunk, láncolt lstára a legobb választás a Merge sort.. A tömb méretének négyzete a benne tárolt elemek ntervalluma. Ebben az esetben nem ér meg Countng sort-ot használn. Vszont mvel tömbben dolgozunk ól működk a Quck sort vagy a Heap sort.. Meg kell tartanunk az egyforma elemek egymáshoz vszonyított eredet sorrendét, így csak stabl rendezések öhetnek szóba. Mvel az elemek ntervallumáról nncs nformácónk, a Merge sortot érdemes alkalmazn.. A tárolt elemek ntervalluma a lsta méretéhez képest kcs. A Countng sort láncolt lstával s O(n) dőgényű, tehát szntén használhatuk. Érdekesség: ha tudn akarod, hogyan lehet könnyen kszámoln bzonyos rekurzív algortmusok (mnt pl a MergeSort vagy a FastFourer algortmus) futásdeét és m s az a Mester tétel, kattnts a nyuszra: Gelle Ktt