Një studim krahasues mbi renditjen e algoritmave dhe ...gazmend-suparaku.com/wp-content/uploads/2016/03/Gazmend-Suparaku-Teme... · republika e shqipËrisË universiteti i elbasanit

REPUBLIKA E SHQIPËRISË

UNIVERSITETI I ELBASANIT

FAKULTETI EKONOMIK

DEPARTAMENTI INFORMATIKË EKONOMIKE

GAZMEND SUPARAKU

PUNIM DIPLOME - MASTER

NJË STUDIM KRAHASUES MBI RENDITJEN

E ALGORITMAVE DHE ZBATIMIN E TYRE

NË MANAXHIM

UDHËHEQËS

DR. ERIND BEDALLI

Phdc. MIRA ÇELA

ELBASAN, 2016

Një studim krahasues mbi renditjen e algoritmave dhe zbatimin e tyre në manaxhim. @2016 Gazmend Suparaku

2

Lista e Përmbajtjes

1.1. Hyrje........................................................................................................................................... 5

2.1. Hyrje në Rekursivitet ............................................................................................................... 6

2.2. Teknikat e Rekursivitetit .......................................................................................................... 6

2.2.1. Backtracking ..................................................................................................................... 6

2.2.2. Përçaj dhe Sundo (D&C Divide & Conquer) ................................................................... 8

2.2.3. Kullat Hanoi ...................................................................................................................... 9

2.2.4. Fractal (Hilbert Curves) .................................................................................................. 10

3.1. Metodat e Renditjes ................................................................................................................ 11

3.1.1. Metoda: Selection Sort .................................................................................................... 13

3.1.2. Metoda: Bubble Sort ....................................................................................................... 14

3.1.3 Metoda: Cocktail Sort .................................................................................................... 17

3.1.4. Metoda: Insertion Sort ................................................................................................... 19

3.1.5. Metoda: Quick Sort ........................................................................................................ 22

3.1.6. Metoda: Merge Sort ........................................................................................................ 27

3.1.7. Metoda: Heap Sort .......................................................................................................... 30

3.1.8. Metoda: Radix Sort ......................................................................................................... 36

3.1.9. Metoda: Shell Sort .......................................................................................................... 40

4.1. Rendësia e algoritmeve të renditjes në manaxhim e të dhënave ......................................... 42

5.1. Renditja e algoritmeve në JAVA (Aplikacioni) .................................................................... 44

5.2. Klasat përgjegjëse për ndërtimin e aplikacionit .................................................................... 44

5.2.1. Ndërtimi i një dritare për të paraqitur modelet e renditjeve që do të aplikojnë disa të

dhëna. Finestra ............................................................................. Error! Bookmark not defined.

5.2.2. Seti i metodave i përdorur për tu marë me Renditjen e Algoritmeve. OrdenacioUtils

Error! Bookmark not defined.

5.2.3. Algoritmet e renditjeve të implementuara në JAVA. Ordenacio Error! Bookmark not

defined.

5.2.3.1. Selection Sort ........................................................ Error! Bookmark not defined.

5.2.3.2. Bubble Sort ........................................................... Error! Bookmark not defined.

5.2.3.3. Cocktail Sort ......................................................... Error! Bookmark not defined.

5.2.3.4. Insertion Sort ......................................................... Error! Bookmark not defined.

5.2.3.5. Quick Sort ............................................................. Error! Bookmark not defined.

5.2.3.6. Merge Sort ............................................................ Error! Bookmark not defined.

5.2.3.7. Heap Sort .............................................................. Error! Bookmark not defined.

5.2.3.8. Radix Sort ............................................................. Error! Bookmark not defined.

5.2.3.9. Shell Sort ............................................................... Error! Bookmark not defined.

5.2.4. Klasa për shfaqjen e evoluimit në grafik të renditjeve të algoritmeve. PanellDibuix

Error! Bookmark not defined.


3

6.1. Biblografia .................................................................................................................................... 44

Lista e Figurave

Figura 1.1: Grupet e mundshme të zgjidhjeve për nga niveli për dy variabla....................... 7

Figura 2: Kullat hanoi............................................................................................................ 9

Figura 3. Rregullat e përgjithshme dhe 3 - nivelet e rrugëtimit në grafik të kthesave të

hilbert..................................................................................................................................... 10

Figura 4. Plani rekursiv dhe rezultati i kthesave të Hilbert.................................................... 10

Figura 5 Grafiku i disa renditjeve të kohës së kompleksitetit më të zakonshme................... 12

Figura 5.1 Koha e ekzekutimit dhe sasia e elementeve të trajtuara sipas funksionit të renditjes

të kompleksitetit..................................................................................................................... 12

Figura 6. Selection Sort..........................................................................................................13

Figura 7. Lista elementëve me rend rritës.............................................................................. 14

Figura 7.1 Shkëmbimi i elementëve...................................................................................... 14

Figura 7.2 Fillimi i krahasimeve në bubble sort nga e majta në të djathtë............................ 14

Figura 7.3 Mënyra e dytë e krahasimeve në bubble sort nga e djatha në të majtë................ 15

Figura 7.4 Përfundimi i renditjes së elementit Bubble Sort................................................... 15

Figura 7.5 Lista e renditur Bubble Sort................................................................................. 16

Figura 7.6 Lista gjysëm e renditur bubble sort...................................................................... 16

Figura 8.1 Lëvizja e elementëve të mëdha nga e majta në të djathtë dhe e elementëve të

vogëla nga e djathta në të majtë Cocktail Sort....................................................................... 17

Figura 8.2 Hapi i fundit i renditjes Cocktail Sort...................................................................18

Figura 9.1 Lista e pa renditur Insertion Sort.......................................................................... 19

Figura 9.2 Proçesi i renditjes së elementëve Insertion Sort................................................... 19

Figura 9.3 Nuk bëjmë më krahasime nëse elementi në të majtë është më i vogël Insertion Sort..... 20

Figura 9.4 Shembulli me letrat e bixhozit Insertion Sort....................................................... 21

Figura 10.1 Lokazimet e QuickSort....................................................................................... 22

Figura 10.2 Përfundimi i hapit të parë Quick Sort................................................................. 23

Figura 10.3 Përfundimi i hapit të dytë................................................................................... 25

Figura 10.4 Proçesi i renditjes së elementëve të metodës Quick Sort................................... 26

Figura 11.1 Ndarja në nën-lista deri në momentin individual MergeSort............................. 27

Figura 11.2 Renditja e elementëve Merge Sort..................................................................... 28

Figura 12.1 Largimi nga rrjënja sjell ndarjen në dy pemë të shkëputura HeapSort.............. 30

Figura 12.2 Përformimi i një nxjerrjeje dhe cili mund të jetë kandidati më i përshtatshëm për

rrënjën.................................................................................................................................... 30

Figura 12.3 Zëvëndësimi i rrjënjës duke mbajtur të kompletuar prioritetin e pemës............ 31

Figura 12.4 Krahasimi Sift Up............................................................................................... 31

Figura 12.5 Krahasimi Sift Down.......................................................................................... 31

Figura 12.6 Prioriteti është akoma i shkelur nëse zgjedhim fëmijen e madh........................ 32

Figura 12.7 Duke zgjedhur fëmijen më të vogël prioritetin e kemi në rregull HeapSort...... 32

Figura 12.8 Operacioni SiftDown HeapSort.......................................................................... 33

Figura 12.9 Krijimi i një heap nga një liste jo e renditur....................................................... 33

Figura 12.10 Kthimi i heap jo i renditur që kishim më lart (fig 12.9) në listë të renditur..... 34

Figura 13.1 Lista e pa renditur fillojmë nga elementi më në të djathtë................................. 36

Figura 13.2 Vendosja e elementeve në “kovat” e duhura sipas nënvijëzimit të numrit Radix Sort. 36


4

Figura 13.3 Nxjerrja e elementëve sipas rendit të “kovave” Radix Sort............................... 37

Figura 13.4 Përfundimi i hapit të 2-të Radix Sort.................................................................. 37



Figura 13.7 Përfundimi I hapit të 5-të ku lista është e renditur Radix Sort........................... 38

Figura 14.1 Përfundimi i hapit të 1-rë i algoritmit shell sort................................................. 40

Figura 14.2 Përfundimi i algoritmit duke përdorur k=4/2=2 Shell Sort................................ 41

Figura 14.3 Përdorimi i k=2/2=1 dhe marin listën e renditur Shell Sort............................... 41

Figura 15.1 Grafiku i Renditjeve te Algoritmeve – Gati për ekzekutim............................... 51

Figura 15.2 Grafiku i Renditjeve të Algoritmeve – Gjatë për ekzekutimit........................... 52

Figura 15.3 Grafiku i Renditjeve të Algoritmeve – Përfundimi i ekzekutimit...................... 52


5

1.1. Hyrje

Nëse do të pyesni pse kompjuterat u krijuan, përgjigjet e mëparshme dhe ato sot qëndrojnë

relevante edhe sot, ndoshta do të jetë për të bërë kuptimin e të dhënave dhe në mesin e shumë

mënyrave në të cilat kjo mund të arrihet, më e thjeshta do të jetë funksionaliteti për të renditur

të dhënat që është për të rregulluar në disa mënyra të disa renditjeje, në fakt kur vjen për të

shkruar një program që të kujdeset për renditjen, aktualisht janë një numër i madh i metodave

të renditjes që mund të përdoren, këto metoda ose algoritme përfundimisht shërbejnë për të

njëjtin qëllim që është renditja e të dhënave, megjithatë ka shumë qasje për ta bërë këtë

kryesisht për shkak se çdo metod ka rastin më të mire (best case) & rastin më të keq (worst

case) disa algoritme marrin shumë kohë për të përfunduar renditjen, ndersa të tjerë mund të

funksionojnë vetëm në disa lloje të caktuara të dhënash.

Çfarë është renditja? Përse është nevoja për te renditur?

Pse kemi nevojë për renditjen algoritmike?

Përpara se ta bëjme këtë megjithatë ne duhet të mendojmë përse është nevoja për renditjen

algoritmike.

Nëse ju japin për të renditur një listë [4,6,2,1,7,3,5] si do ta bënit?

Me siguri do ta bënit në menyrën më të thjeshtë deri kur vlerat të ishin [1,2,3,4,5,6,7]

shumë e thjeshtë atëhere pse në kemi nevoje për algoritme?

Kompjuteri duhet të meret me sasi të medha të dhënash, nga kjo do të thotë mijera, qindra të

dhënash, sigurisht një kompjuter nuk mund të arsyetojë si një njeri se si duhet renditur kjo listë,

ka të bëjë me kuptimin e kontekstin e gjithë listës.

Për shembull:

Duke parë listën origjinale [4,6,2,1,7,3,5] ne e dimë që lista përmban numrat nga 1 deri në 7

dhe pa dyshim renditja e saktë është [1,2,3,4,5,6,7] ne i vendosim ato në atë renditje për njerëzit

është shumë thjeshtë por kompjuterat nuk funksionojnë në atë mënyrë, një kompjuter thjesht

ekzekuton komandat e cila është arsyea pse programuesit marin mundimin për të vendosur

instruksione që mund të jenë të lehta për të kryer, një kompjuter nuk mund të shohë të gjithë

listën si tërësi as të kuptojë kontekstin, të cilën e bëjnë renditjen shumë më të vështirë nga

prespektiva e programuesve, veçantërisht pasi që nuk e kanë iden se çfarë të dhënash mund të

mbajë programi.

Pra 3 janë:

1. Mund të jetë sasi e madhe të dhënash

2. Ne rendisim nga konteksti gjë që kompjuteri nuk mund ta bëjë

3. Një shumellojshmëri e gjërë të përmbajtjes që mund të hasen


6

2.1. Hyrje në Rekursivitet

Rekursiviteti është kur proçedura apo funksioni i referohet në definicionin e vet. Nje shembull:

Një person mban një pasqyrë në dorë dhe shikon veten e tij nëpërmjet një tjetër pasqyrë që ka

në këmbë. Në një mënyrë mund të thuash, në praktikë është kur proçedura apo funksioni

prodhon thirrje të njëpasnjëshme deri në momentin ku nuk mund të prodhojë më thirrje të

njëpasnjëshme.

Një dizenjim i rekursivitetit prezanton:

Kushtet që ndajnë trajtimin e rasteve të rëndësishme nga ato jo-të rëndësishme

Trajtimi i një rasti të rëndësishëm ka aspekte të një proçesi përsëritës

2.2. Teknikat e Rekursivitetit

2.2.1. Backtracking

Le të shohim një nga teknikat pricipale të teknikave të rekursivitetit të njohur si kthimi mbrapa

(Backtracking), në këtë teknikë ajo që bëjmë është një proçes i një kërkimi sistematik në

hapsirën e zgjidhjeve të mundshme deri sa të gjejmë një zgjidhje të vleshme.

Teknika e kthimit mbrapa është një teknikë me qëllim të përgjithshëm, që shërben teorikisht

për të zgjidhur të gjitha llojet e problemeve. Strategjia e një algoritmi që bazohet në

backtracking është shumë e thjeshtë dhe ka karakteristikat e mëposhtme:

Është një strategji me qëllime të përgjithshme.

Realizon një kërkim sistematik brënda hapsirës së zgjidhjeve, kjo shpesh është jo

efiçente në praktikë.

Provohen të gjitha hapat deri sa të gjendet zgjidhja përfundimtare dhe nëse gjatë rrugës

arrijmë në një gjendje që nuk ka zgjidhje atëherë kthehemi në gjendjen e mëparshme

Strategjia e backtracking paraqet veprimet e mëposhtme:

Konsideron zgjidhjen e tabeles (X1, X2,…,Xn)

Në çdo moment algoritmi gjen një gjëndje k me një zgjidhje të pjesshme

(X1,X2,…,Xk | k ≤ n)

Nëse mund të vendosim një element të ri për zgjidhjen dhe për të vazhduar përpara

gjendja bëhet k+1

Në qoftë se nuk provohen elementë të tjerë jemi në gjëndjen Xk

Nëse nuk ka më elemente për të provuar atëhere kthehemi në gjëndjen k-1

Kjo bëhet deri në momentin kur nuk ka më zgjidhje të pjesshme për të provuar.


7

Në thelb kjo është teknika më bazike që një person mund ta perdorë për zgjidhen e një problemi

avantazhi është se duke përdorur mjetet që na propozon programimi rekursiv, algoritmi

rekursiv i backtracking është shumë më i lehtë për tu implementuar.

Ajo që ne bëjmë është një kërkim në thellësine e pemës së mundësive e zgjidhjeve (fig 1.1)

Figura 1.1: Grupet e mundshme të zgjidhjeve për nga niveli për dy variabla

Një shembull i thjeshtë i backtracking është shembulli i bankomatit (ATM), nëse ne drejtohemi

në një bankomat në vëndet europiane vlerat monetare që i përmban bankomati janë 50 € dhe

20 € në momentin kur bankomati na njeh kartën dhe pranon passwordin e log-init (kodi pin)

atëherë ne mund të japim komandën për tërheqjen e parave, në qoftë se ne do donim të

tërhiqnim 80 € hapat që do te merrte ATM janë:

Hapi 1: kërkon për vlerën më të madhe qe ka në dispozicion 50 €

Hapi 2: kërkon nëse vlera përseri do ishte 50 € do ishte zgjidhja perfundimtare? Jo, ai ka në

dispozicion vlerën tjetër pra 20 € dhe ktu kalojmë në veprimin k+1 sic e përmendëm më lart

Hapi 3: kërkon për vlerën tjetër brënda hapsirës së zgjidhjes për plotësuar shumën që kërkon

individi shikon që asnjë nga dy vlerat monetare për vlerën pasardhëse nuk është zgjidhja dhe

jemi në gjëndjen Xk

Hapi 4: nuk ka vlera monetare për te vepruar dhe kthehet në gjendjen k-1 deri në momentin

kur të plotësohet shuma që kërkon individi

Hapi 5: vlerat monetare që do të dalin nga bankomati janë 20€, 20€, 20€, 20€


8

2.2.2. Përçaj dhe Sundo (D&C Divide & Conquer)

Këtu ju prezantojmë teknikën e dytë e rekursivitetit teknikën përçaj & sundo (divide &

conquer) ndryshe nga teknika e mëparshme nuk është me qëllim të përgjithshëm. Do të thotë

që duhet të përmbushë një numër kushtesh për tu aplikuar, në shumicën e rasteve kur ne japim

një algoritëm mënyra e të parit nga teknika D&C përfitojmë një ulje të kostos të

kompleksiteteve asimptotike.

Në këtë lloj strategjie që trajtohet është ndarja e një probemi të madh në probleme më të vogëla,

menjëhere sapo kemi gjetur zgjidhjen e nën-problemeve të vogëla këto kombinohet për të

gjetur zgjidhjen e problemit të madh.

Çfarë lidhje ka rekursiviteti me këtë strategji?

Nësë ndarja në nën-probleme dhe kombinimet e zgjidhjeve është që të dërgojë në një formë

përsëritëse, duke përfituar nga mjetet e rekursivitetit që na jep programimi, marim si një

algoritëm rezultaten e një mjeti elegant, shpesh optimale, lehtësisht të kuptueshme dhe të

programueshëm.

Strategjia e përgjithshme e divide & conquer D&C është:

Divide_&_conquer(p: problem){

Divide (p, p2, p3, ... ,pk); // nën-problemet

for (i=1, 2, ... , k){

s1 = zgjidh (p1); // marrim k zgjidhje

}

zgjidh = kombino (s1, s2, ... , sk); // kombino k zgjidhje

}


9

2.2.3. Kullat Hanoi

Ky është një shembull i zgjidhjes së strategjisë së D&C shumë i qartë për shumë arsye:

a. Ne kemi një zgjidhje të thjeshtë bazuar në modelin që ekspozuam më lart.

b. Algoritmi i rezultuar është shumë më i thjeshtë dhe më i kuptueshëm.

c. Algoritmi final është shumë i thjeshtë, i lehtë për të kuptuar dhe studentët që e shikojnë

për herë të parë i duket si një numër magjie.

Problemi i kullave të hanoit bazohet si në hapat e mëposhtme:

1. Vetëm një disk mund të lëvizet në një kohë

2. Çdo lëvizje konsiston në marrjen e diskut sipërm në një nga shtyllat dhe të bësh

vendosjen e atij disku në pjesën e sipërme e një shtylle tjetër

3. Asnjë disk nuk mund të vendoset lart një disku tjetër më të vogël se vetja

Figura 2. Kullat hanoi

Ajo që bëjmë tani është të zhvillojmë një algoritëm që implemeton këtë strategji duke përdorur

teknikat e rekursivitetit. Skema për zgjidhjen e problemit do të jetë:

Hanoi (int n, int A, int B, int C) {

If (n==1) {

lëvizja(A, B);

} else {

Hanoi (n-1, A, C, B);

lëvizja(A, C); // Afishon lëvizjet nga A ne C

Hanoi (n-1, B, A, C);

}

}

Ajo që bën kjo strategji është të realizojë lëvizjet dhe të presi për zgjidhjen e rekursivitetit.

Rezultati është lista e lëvizjeve që bëhen për të zgjidhur problemin.


10

2.2.4. Fractal (Hilbert Curves)

Kthesat e Hilbertit janë një shembull tipik i një dizenjimi të rekursivitetit që arrin të

implementojë një rrugë grafike me thelb rekursivitetin. Bëhet falë për të implementuar një

algoritëm që të jetë i aftë për të kryer një grafik me rrugë rekursive me çfarë do niveli të

detajuar, ta bëjë gjithashtu në një formë të qartë dhe intiutive. Përkufizimi i kthesave te hilbertit

për këtë rrugë grafike është:

Figura 3. Rregullat e përgjithshme dhe 3 - nivelet e rrugëtimit në grafik të kthesave të hilbert

Një dizanj tradicional të një algoritmi që vizaton kthesat e Hilbert, çfarëdo nivel do të jetë i

komplikuar. Këtu mund të bëjmë një plan për të dizenjuar një algoritëm rekursiv që zgjidh një

qasje që është në vetvete gjithkund rekursive. Me fjalë të tjera idea do të ishte: Përse nuk mund

të programojmë një plan rekursiv që të jetë i gjithi rekursiv.

Rezulati është i qartë, algoritmi rezultant është shumë i thjeshtë, i lehtë për tu kuptuar dhe i

bazuar në principin e hyrjes (baza përsëritëse) e vlefshme për çdo nivel të perfaqërsimit. Në

praktikë lartësia e nivelit përfaqësues të algoritmit varet nga rezultati i zgjidhjes së pajisjes. Në

këtë rast ne nuk e përdorim rekursivitetin vetëm me objektivin për të përmisuar apo thjeshtuar

ndonjë gjë, po edhe për të lehtësuar projektimin e dizenjimin dhe programimit

Bëhet fjalë për rregullat në formën e rekursivitetit në figuren 4 mund të shikoni shembujt e

implementuar dhe rezultatin.

Figura 4. Plani rekursiv dhe rezultati i kthesave të Hilbert


11

3.1. Metodat e Renditjes

Përpara se të fillojmë të tregojmë metodat e renditjes me përpara duhet të shpjegojmë

kompleksitetet asimptotike, kompleksitetin e kohës dhe se çfarë është simboli i O-së së madhe

(Big O notation).

Përpara se të gjithash çfarë është kompleksiteti i kohës dhe pse e diskutojme këtë, algoritmet

janë krijuar për të ekzekutuar detyra, ato shpesh nuk janë vetëm të interesuar vetëm për

zgjidhjen e problemeve por gjithashtu edhe për të zgjidhur atë në kohën më të shkurtër të

mundshme. Kompleksiteti i kohës (Time complexity) është matja e efiçensës

Në matematikë simboli i O-së së madhe përshkruan sjelljen e limitit të një funksioni kur

argumenti ka një vlerë infinite ose konkrete, zakonisht në aspektin e funksioneve të thjeshta,

simboli O është përdorur sepse norma e rritjes e një funksioni i është referuar edhe menyrës së

funksionit. Simboli O në shkenca kompjuterike është përdorur për të përshkruar përformancën

ose shpejtësinë e një algoritmi, në mënyrë specifike simboli O rastin më të keq dhe mund të

përdoret për të përshkruar kohën e ekzekutimit që kërkohet.

Në këtë temë do shfaqim shumë shembuj të renditjeve të algoritmeve të ndryshme, dhe e gjithë

idea është sepse futja e më shumë se një algoritëm në temë është sepse disa prej tyre janë më

efiçent se disa algoritme të tjerë, si e masim ne efiçensën? Ne e bëjmë këtë duke parë

kompleksitetin e kohës (time complexity) wikipedia thotë se kompleksiteti i kohës i një

algortimi vlerëson sasin e kohës që merret nga një algoritëm që ekzekutohet si një funksion i

gjatësisë së vargut që përfaqesohet si input.

Koncepti është shumë i thjeshtë, le të shohim kam një liste me “n” elementë, pyetja është sa

herë më duhet të kaloj në këtë listë përpara se të mar çfarë do që të jetë e dua që të jetë e kryer

(Done). Për shembull un dua të zgjedh elementët më të vogëla, ajo që duhet të bëj është të kaloj

nga e majta në të djathtë dhe më duhet të kontrolloj çdo element, vetëm në momentin mbasi

kam përfunduar kalimin në të gjithë listën atëherë mund të them se cili është numri më i madh

apo më i vogël.

Ky algoritëm duhët të bëjë “n” krahasime, pse “n” sepse kemi një listë të madhësisë “n” dhe

kalon në çdo element, kjo do të thotë se algoritmi duhet të kalojë në “n” element kjo quhet

algoritmi (n2) : n-krahasime * n-elemente = n2-kohe, ky numër i krahasimeve aktualisht është

i matur në elementë “n” padyshim që një algoritëm me kohë (n2) do të marë më shumë kohë

për zgjidhjen se sa një algoritëm më kohë (n) dhe më pas në kemi në mesin e algoritmve (n log

n) kohë, do të flas për këtë më poshtë në momentin që algoritmi ka (n log n) kohë.


12

O(1) < O(n) < O (n log n) < O (n2)

O(1) – Koha konstante (Constant time)

O(n) – Koha Lineare (Linear time)

O(n log n) – Koha Linearitmike (Linearithic time)

O(n2) – Koha ne katror (Quadratic time)

O(f(n))

O - përshkruan si ndryshon nr i hapave për zgjidhjen e problemit kur ndryshon permasa e inputit

f(n) - nr i hapave të nevojshëm për zgjidhjen e problemit

n - është përmasa e inputit

Figura 5 Grafiku i disa renditjeve të kohës së kompleksitetit më të zakonshme

Figura 5.1 Koha e ekzekutimit dhe sasia e elementëve të trajtuara sipas funksionit të renditjes

të kompleksitetit


13

3.1.1. Metoda: Selection Sort

Arsyeja pse zgjodha të filloj me selection sort është sepse është më intuitive nga algortimet e

tjera të renditjeve, nëse do të kishim një pako me letra bixhozi do ti rendisnim nga letra më e

vogël deri tek letra më e madhe, kushti për selection sort është shumë i thjeshtë, në thelb ajo

që duam të bëjmë është që ne të kalojmë përgjatë listës, ne do të gjejmë elementët më të vegjël

dhe i dërgojmë në të majtë të listës më pas ndërtohet një nën-listë e cila përjashton elementët e

renditura. Në këtë mënyrë në çdo kalim në listë do të marim elementin më të vogël brënda çfarë

do që të jetë në listë dhe do ta vendosim në fillim.

Tani një gjë e rëndësishme të theksohet është se si në fakt mund të gjejmë elementin minimal

brënda në listë, do të na duhet një variabel jashtë listës originale që në fakt mban shënim vlerën

minimale, pra ajo që do të ndodhi është se ne do të kalojmë gjatë listës dhe do të gjejmë se cili

është elementi më i vogël, do të vendos elementin e parë si minimum në variablin jashtë listës

dhe do të kaloj gjatë gjithë listës për të parë nëse ka elementë më të vegjël, nëse ka eliminojmë

elementin e parë që vendosëm në variablin e jashtëm dhe vendosim elementin e ri më të vogël

se ai që ishte më përpara, duke bërë këtë në të gjithë listën do të jemi të aftë për të gjetur

elementin më të vogël.

Në momentin që gjejmë elementin më të vogël ajo që do të bëjmë është të ndyshojmë vendin

e elementit më të vogël me atë që është në fillim, kjo është ekzaktësisht se si ne duam tek lista

të renditen elementët më të vogëla në të majtë dhe elementët më të mëdha në të djathtë,

elementët që tani janë të vendosur në të majtë listës konsiderohen të renditur.

Le të flasim për kohën, sa efiçent është selection sort?

Për fat të keq selection sort është algoritëm shumë i

thjeshtë dhe koha e kompleksitetit të tij është O(n2), ti

hedhim një sy së si është selection sort, në kalojmë

vazhdimisht në listë aq herë sa elementë ndodhen në listë

sepse në çdo kalim në listë një element është i renditur,

duke parë së selection sort bën “n” krahasime dhe “n”

elementë atëherë kompleksiteti i kohës është “O(n2)”

Tani na duhet të dimë se çfarë lloji të dhënash mund të

ketë një listë ajo do të bëjë të njëjtët krahasime, kjo do të

thotë edhe pse ne mund ti japim një listë të renditur

selection sort nuk ka asnjë mënyrë që algoritmi të gjejë

që lista në të vërtetë është e renditur, më poshtë do të

shikojmë algoritme të tjera të cilën disa prej tyre janë të

aftë të mbarojnë më shpejtë nëse lista është e renditur,

edhe rasti më i keq i selection sort është gjithashtu O(n2) Figura 6. Selection Sort


14

3.1.2. Metoda: Bubble Sort

Bubble Sort është një algoritëm bazik i cili funksionon me kushtin duke ndryshuar elementët

“komshi” më të afërt, le të themi se duam një listë të renditur me rend rritës (figura 7), kjo do

të thotë që elementët më të vegjël shkojnë në krahun e majtë dhe elementët e mëdhenj shkojnë

në krahun e djathtë, duke u bazuar në këtë ide bubble sort krahason dy elementet më të afërt

“komshijtë” (figura 7.1),

Figura 7. Lista elementëve me rend rritës

Nëse elementi në të djathtë është më i vogël se elementi në të majtë atëherë ato ndryshojnë

vëndet,

Figura 7.1 Shkëmbimi i elementëve

Edhe një herë: kemi një listë të pa renditur për të mbajtur mend se çfarë jemi duke bërë unë

vendos një shigjetë poshtë elementit, në çfarëdo vendi që të jetë shigjeta elementi do të

krahasojë elementin ngjitur në të djathtë, kjo do të thotë që do të fillojë nga elementi i parë më

në të majtë dhe do të përfundojë në elementin e parafundit të listës (fig 7.2)

Figura 7.2 Fillimi i krahasimeve në bubble sort nga e majta në të djathtë


15

Sigurisht që mund të përdorni edhe mënyrën tjetër ku shigjeta në çfarë pozicioni të ndodhet do

të krahasojë me elementin në të majtë, kjo do të thotë që fillojmë nga elementi i dytë dhe do të

mbarojë në elementin e fundit të listës (fig 7.3).

Figura 7.3 Mënyra e dytë e krahasimeve në bubble sort nga e djatha në të majtë

Të dy implementimet janë njëlloj të vlefshme dhe kjo nuk ndyshon mënyrën se si algoritmi

sillet, duhet të theksojmë se objektivi i bubble sort është elementet më të mëdhenj të jenë

gjthmonë në krahun e djathtë.

Shikojmë kemi 2 dhe 7 këtu nuk bëjmë asgjë thjeshtë vazhdojmë, numri 7 duhet të shkojë në

të djathtë ndryshojmë vëndet 7 me 6, pasi 7 është më e madhe, tani krahasojmë 7 me 4, duke

qënë se 7 është përsëri më e madhe lëvizim në të djathtë, edhe me vlerën 1 po i njëjti veprim,

tani krahasojmë 7 me 8, 7 ishte elementi më i madh që kishim parë deri më parë, tani 8 është

aktualisht elementi më i madh, këtu nuk bëjmë asnjë ndryshim kshu që lëvizim dhe krahasojmë

8 me 5, 8 > se 5 lëvizim në të djathtë, edhe me 3 po i njëjti veprim pasi 8 është > se 3. (Fig 7.4)

Figura 7.4 Përfundimi i renditjes së elementit Bubble Sort

Ne kemi bërë një kalim në të gjithë listën le të shikojmë se çfarë kemi bërë këtu, nga inspektimi

i listës ne realizuam se numri 8 është numri më i madh duke kaluar nga e majta në të djathtë,

ajo që kemi bërë është që e kemi lëvizur 8 gjatë gjithë rrugës nga e djathta,

Siç mund të shikojmë edhe elementi 7 ka lëvizur disa herë por kjo nuk është e rëndësishme

këtu, me rëndësi është se elemetët më të mëdhenj duhet të jenë në të djathtë të listës, tani le të

shikojmë se çfarë kemi ndryshuar dhe çfarë jo, kur elementi ka poshtë tij shigjetën aktualisht

është më i madh se elementi në të djathtë atëherë do të thotë që janë jashtë rendit, ne i vendosim

në rend duke i ndryshuar ato (fig 7.1 me lart).

Mirë ne kemi një hap deri tani kthehemi mbrapsh dhe përsërisim të njëjtin proçes të algoritmit,

në hapin tjetër 7 është elementi i dytë që shkon në të djathtën e listës, tani ¿na duhet neve që të

krahasojme 7 me 8? Pergjigja është JO, duke qënë se elementi më i madh është dërguar në të

djathtë ai është aktualisht në vendin që i përket dhe nuk ka asnjë sens që të bësh një krahahasim

midis tyre sepse nuk mund të gjesh një element më të madh se ai, dhe ky proçes bëhet për çdo

element dhe në këtë mënyrë ne e kemi të renditur listën tonë (Fig 7.5).


16

Figura 7.5 Lista e renditur Bubble Sort

Le të hidhemi të flasim pak për kompleksitetin e kohës, siç mund të shikojmë bubble sort

funksionon në këtë mënyrë, duket n-elemente n-kohe, kjo do të thotë që bubble sort funksionon

me kompleksitetin e kohës O(n2) në termin e përformancës nuk është optimale duket si kur ka

të njëjtën kompleksitet kohe me Selection Sort, gjithsesi duke qënë se po flasim për selection

sort unë paraqita dy raste (best case) dhe (worst case).

Në rastin e selection sort ajo nuk mund të optimizioje kshu që ajo merr kohën O(n2) pa marë

parasysh se çfarë elementësh mund ti japësh, ky nuk është rasti i bubble sort për ta shpjeguar

këtë lë të shohim një listë gjysëm të renditur (Figura 7.6):

Figura 7.6 Lista gjysëm e renditur bubble sort

Në pjesën e parë të figurës lista është pothuajse pak a shum e renditur, ajo që më duhet të bëjë

në fillim është të rendis elementët më të mëdhenj në të djathtë, ne kaluam vetëm një herë dhe

teknikisht ne nuk njohim asgjë së çfarë është përpara elementit që ne vendosëm në rend

sigurisht ne nga inspektimi mund të themi që lista tashmë është e renditur, ne aktualisht mund

të implementojmë një kërkim shumë të thjeshtë në algoritmin bubble sort.

Ajo që un do të bëj është do të kaloj edhe një herë në të gjithë listën, duhet të vërejmë se kërkimi

shkon deri në fund të listës pa bërë asnjë ndryshim është interesante sepse tregon që lista është

e renditur, ajo që ne duhet të bëjmë është shikojmë që nëse në një kërkim nuk bëhët asnjë

ndryshim në të gjithë listën mund të konkludojmë që lista është e renditur dhe të përfundojë

më shpejt, kshuqë që skenari më i mirë për bubble sort është O(n)-kohë sepse i nevojitet ti

shkojë listës vetëm një herë deri në fund realizon që nuk ka ndyshime për të bërë dhe përfundon.

Rasti më i mirë është kur ne i japim një listë të renditur ka nevojë të kërkojë të shikojë vetëm

një herë n-kohë, rasti më i keq është kur i japim një listë jo të renditur mirë që përmes të cilës

në shumicën e rasteve do te marim pak a shum O(n2) – kohë.

skenari më i mirë (best case) është O(n)-kohë,

skenari më i keq (worst case) është O(n2)-kohë.


17

3.1.3 Metoda: Cocktail Sort

Aktualisht është një tjetër lidhje fenomenale që ne duhet të shikojmë, nuk është modeli i plotë

i bubble sort duke i kushtuar më shumë vëmendje elementëve më të mëdhenj, le të shikojmë

elementët më të vegjël, duhet të marim parasysh që në bubble sort elementët e vegjël nuk

lëviznin shumë ne fakt ato lëviznin shumë ngadalë për të kaluar në krahun e majtë të listës, kjo

është për termat “lepuri (rabbits)” dhe “breshka (turtle)”, elementët e mëdha konsiderohen si

“lepur (rabbits)” arsyea pse ne i quajmë kështu është sepse ato lëvizin shumë shpejt në krahun

e djathtë të listës, elementët e vogëla quhen “breshka (turtle)” sepse ata lëvizin shumë pak

lëvizja është ekstremisht shumë e ngadalë në shumicën e rasteve ato mund të lëvizin vetëm një

herë.

Si mund ti bëjmë të gjithë elementët “lepur (rabbits)”?

Si mund ti lëvizim nga e majta në të djathtë në të njëjtën kohë?

Këtu është momenti kur futet Cocktail Sort objektivi i cocktail sort është ekzaktësisht si bubble

sort mirëpo deri tani është vendosur lëvizja vetëm në një drejtim nga e majta në të djathtë në

këtë algoritëm në mund të lëvizim edhe nga drejtimi i kundërt. Lëvizja e parë që duam të bëjmë

është të dërgojmë elementët e mëdha në të djathtë, në momentin që do të kthehemi mbrapa ne

do lëvizim elementët më të vogëla në të majtë, në fakt le të shikojmë se si fuksionon.

Figura 8.1 Lëvizja e elementëve të mëdha nga e majta në të djathtë dhe e elementëve të

vogëla nga e djathta në të majtë Cocktail Sort

Ajo që do të ndodhi është që do të lëvizë përpara në fillim nuk ka asgjë të re në këtë sepse është

ekzaktesisht siç e bën bubble sort, ajo që do të bëjmë tani është të lëvizim mbrapa, siç mund të

shikojmë jemi duke krahasuar me elementin ngjitur nga e majta “komshiun” nëse elementi

është më i vogël se elementi “komshi” atëherë ndërrojmë vëndet,

ajo që po bëjmë tani është të shtyjmë elementët më të vogëla në të majtë të listës, duke

kompletuar hapin e parë sigurisht shikojmë që janë vendosur në vëndin e duhur elementi i parë

i madh dhe elementi i parë i vogël.


18

Nëse doni të përdorni metodën bubble sort do te ishte një “breshke e madhe” dhe do lëvizë

shumë ngadalë krahasuar pak ashum me elementët e tjerë, gjithsesi falë mënyrës se si cocktail

sort fuksionon një element renditet në krahun e djathtë dhe një në krahun e majtë.

Le të vazhdojmë me renditjen e algoritmit në këtë mënyrë ne mund të shikojmë se sa efiçent

më shumë është nga bubble sort, duke qënë se në hapin e fundit nuk ndodhi asnjë ndryshim

vëndesh ne mund të konkludojmë që në fakt lista është e renditur. (fig 8.2).

Figura 8.2 Hapi i fundit i renditjes Cocktail Sort

Këtu është një gjë interesantë për tu mbajtur shënim nëse shikojmë bubble sort apo selection

sort le të themi në një kalim algoritmi jep “O(n)-krahasime” do të thotë sepse është në zonën e

“O(n)-elemente” dhe ne shkojmë në çdo njërin prej elementëve dhe bëjmë krahasime, ky nuk

është rasti i cocktail sort sepse një kalim në algoritmin e cocktail sort lëviz përpara në listë dhe

më pas mbrapa ne aktualisht kemi bërë 2 “n-krahasime” sigurisht sepse çdo element në listë

është parë dy herë, kjo do të thotë fatkeqsisht që algoritmi cocktail përformon në O(n2)

kompleksitet kohe.

Pse? Sepse kërkon n-elemente, n-kohë

Cocktail Sort është pak më e shpejtë se bubble sort, gjithsesi asnjëherë nuk është mjaft për të

ndryshuar kompleksitetin e kohës.

Në termat e rasteve më të mirë (best case) dhe rasteve më të këqinj (worst case), cocktail sort

është pak më e shpejtë se bubble sort, kujtojmë se në bubble sort nëse në një kalim në të gjithë

listën nuk do të kishim ndryshime vëndesh ne mund të konkludojmë që lista është e renditur

dhe nuk nevojitet më hapa për të bërë të njëjtin aplikim dhe cocktail sort pra është kështu




19

3.1.4. Metoda: Insertion Sort

Deri tani kemi parë selection sort, bubble sort dhe cocktail sort, të tre këto algoritme janë shumë

intuitive ne kalojmë përgjatë gjithë listës duke renditur një element dhe përfundimisht do të

rendisim të gjithë listën.

Tani shikojmë metodën e insertion sort është një algoritëm që vepron mbi një premisë pak më

ndryshe, insertion sort bën vetëm një kalim në të gjithë listën por në momentin që arrin në

fundin e listës çdo element është në pozicionin e tij dhe lista është e renditur. Fatkeqësisht kjo

nuk do të thotë që është një algoritëm efiçent, le të shikojmë se si insertion sort funksionon.

Kemi një listë jo të renditur në të njëjtën mënyrë si tek bubble sort vendosim një shigjetë poshtë

elementit në listë, kjo na lejon neve që të mbajmë gjurmimin në progresin tonë, diçka unike në

insertion sort është fakti së çdo element që është në majtë të shigjetës është aktualisht i renditur,

i renditur nuk do të thotë që është në pozicionin e tij të saktë por nuk është ky rasti, e renditur

do të thotë që ato janë aktualisht të renditur në rendin rritës por për qëllimin e demonstrimin ne

sigurisht që do ti vendosim elementët në rendin rritës

Figura 9.1 Lista e pa renditur Insertion Sort

Në insertion sort ne nuk fillojmë në elementin e parë por ne fillojmë në elementin e dytë, idea

është që çdo element që ka poshtë shigjetën un dua ta vendos në pozicionin e saktë në të majtën

e listës së renditur, le ti hedhim një sy shembullit (figura 9.2)

Figura 9.2 Proçesi i renditjes së elementëve Insertion Sort


20

Ne filluam në elementin e dytë që është 7, tani 7 është e renditur në respekt me 2-in dhe kjo do

të thotë që ne nuk kemi bërë asnjë ndryshim dhe lëvizim përpara, tani shkojmë tek numri 6,

elementët [2,7,6] është e pa renditur ajo që duhet të bëjmë është të ndryshojmë vëndet 6 me 7,

tani kemi [2,6,7] që është e renditur, lëvizim përpara përseri dhe kemi [2,6,7,4] sigurisht që 4

nuk është në pozicionin e saktë të saj në respekt me listën në majtë kshu që ajo që do të bëjmë

është do ta dërgojmë në pozicionin mbrapa që i përket, nëse e keni kuptuar modelin deri tani

sigurisht që numrin 1 duhet ta dërgojmë në fillim fare në krahun e majtë të listës.

Siç mund të shikoni ne jemi duke lëvizur përpara në listë dhe çdo element i ri që gjejmë në listë

ne e vendosim atë në pozicionin e duhur në krahun e majtë të listës, kjo do të thotë që shigjeta

do të bëjë një kalim të plotë nga e majta në të djathtë, ne do të kemi një listë të plotë të renditur

dhe kjo është më pak fjalë se si funksionon insertion sort.

Le të shikojmë se çfarë krahasimesh kemi bërë, ne fillojmë nga elementi i dytë dhe e

krahasojmë atë me elementin e parë nëse elementi i dytë është më i vogël atëherë ndryshimi i

vëndeve është i nevojshëm për tu bërë, duke qënë se nuk ka më elementë në të majtën mbas

këtij ndryshimi ne bazikisht ndalojmë, shkojmë më tej dhe lëvizim shigjetën përpara dhe ky

është proçesi i krahasimeve që ne bëjmë vazhdimisht.

Çfarë do elementi të ri të jetë vendosur shigjeta ne do ta kontrollojmë atë me elementin në të

majtë nëse vlera e tij është e vogël atëhere do të bëhet shkëmbimi, mbas shkëmbimit do të na

duhet ta krahasojmë vlerën e tij me “komshiun” e ri në të majtë dhe sigurisht do të na duhet ta

përsërisim këtë në listë deri sa të gjejmë një nga dy kushtet:

1. Nëse elementi “komshiu” i tij në të majtë është më i vogël mund të ndalojmë të gjithë

sëbashku, tani përse ne nuk kemi më nevojë të krahasojmë nën-listën në të majtë sepse

ajo tashmë është e renditur, nëse “komshiu” në të majtë është më i vogël është e sigurt

se të gjithë elementët e tjerë janë të vegjël, kjo do të thotë që në momentin kur gjejmë

një element të vogël në krahun e majtë është e sigurt që ai element është në pozicionin

e tij të saktë.

Figura 9.3 Nuk bëjmë më krahasime nëse elementi në të majtë është më i vogël Insertion Sort

5<6 -nuk është më nevoja për të bërë krahasime, çdo element në të majtë do të jetë më i vogël.


21

2. Gjithashtu është një kusht i dytë dhe ne e shikojmë në momenti kur dërgojmë elementin

1 në fillim në të majtë të listës, nëse një element është vëndosur në fillim të listës atëherë

ai është pozicioni i tij i saktë, në ndonjë një pikë ku kemi një element që është më i

vogël se e gjithe nën-lista e renditur në të majtë ky do të jetë përfundimi i kushtit për të

gjithë shkëmbimet, kur ne rendisim ekstremisht në të majtë nuk mund të shkojë më tutje

dhe për këtë arsye ekstremisht e majta është pozicioni i tij

Mundet sigurisht që të zëvëndesohen nga elementë që mund të vijnë dhe me këtë logjike

ne aktualisht kemi kompletuar renditjen e të gjithë listës me insertion sort.

Figura 9.4 Shembulli me letrat e bixhozit Insertion Sort

Tani le shikojmë kompleksitetin e kohës, siç e përmenda dhe në fillim insertion sort mund të

duket shumë efiçent sepse i duhet vetëm të kalojë vetëm një herë në listë, fatkeqesisht nuk është

ky rasti sepse siç konsiderohet kthimi i vetvetes mbrapa në listën e renditur.

Aktualisht është duke bërë sigurisht krahasime me “komshiun” e tij dhe çdo njeri prej

elementëve në kohë, në këtë rast është shumë e vështirë të shikohet n-krahasime mbi n-

elementë por fatkeqësisht ky është rasti dhe koha e kompleksitetit për insertion sort është O(n2)

Gjithsesi ashtu si bubble sort edhe insertion sort ka një rast të mirë (best case) të kohës së

kompleksitetit dhe kjo vjen fare natyrshëm nëse e shikoni mënyren se si është shkruar algoritmi

në vetvete sepse nëse ne do ti japim metodës insertion sort një listë të renditur çdo element ku

është shigjeta poshtë do të shikojë nga “komshiu” në të majtë vetëm një herë dhe thotë: oh hey

un jam në pozicion, shigjeta do të lëvizë tek elementi tjetër elementi do shikojë përseri tek

“komshiu” në të majtë dhe të japë të njëjtën përgjigje: oh hey un jam në pozicion, dhe kjo do

përsëritet për çdo element që është në listë që do rezultojë në një total të madh të O(n)

Dhe e anasjellta nëse ne do ti japim insertion sort një liste të parenditur kostoja e kohës së

kompleksitetit do të jetë O(n2)




22

3.1.5. Metoda: Quick Sort

Quicksort është një algoritëm që mbështetet kryesisht në recursion, tani ajo që do të bëj është

se do prezantoj menjëherë shembullin, në këtë shembull kemi një listë të parenditur që

quicksort të përformojë do ti duhen 3 lokazime: 1. E majta, 2. E djathta dhe 3. Bosht

Figura 10.1 Lokazimet e QuickSort

E ngjashme me numrat e renditjeve të algoritmave që kemi parë më para, në quicksort ka

variacione të lehta ku veçantërisht ku ne e vendosim boshtin nuk ka rëndësi. Disa

implementime të quicksort e vendosin boshtin në elementë të rastit, gjithsesi ne do ta shmangim

këtë problem dhe do ta vedosim boshtin në të majtë dhe harruam lokalizimet të majtën dhe të

djathtën, ato do te shkojnë ekstremisht në krahun e majtë dhe të djathtë të listës, duhet të kemi

parasysh se nuk është gjithmonë ky rasti nëse un vendos që i jap quicksort një nën-list dhe është

dicka që ne do ta shikojmë më vonë, lokazimi i majtë dhe i djathtë do të shkojnë ekstremisht

në të majtën dhe në të djathtën e nën-listës, sigurisht ku ne i themi quicksort që të veprojë ne

do ti japim të gjithë listën.

E cila kjo është arsyea se për të kaluar në hapin e parë duhet të kemi lokalizimin e majtë dhe të

djathtë në ekstremet e tyre në të gjithë listës të pa renditur, pra idea është kjo elementi në majtë

dhe elementi në të djathtë janë të krahasueshëm, nëse ato janë jashtë rendit dhe në këtë rast

sepse jemi aktualisht duke i renditur në rendin rritës, pra ajo që duam ne është që elementi në

majtë të jetë më i vogël se elementi në të djathtë nëse nuk është kështu atëherë ndryshojmë

vëndet. (Figura 10.2)

Në këtë rast 3 > 2, gjithcka është në rregull kshuqë vazhdojmë, tani kemi lokalizimin e majtë

dhe të djathtë, cilin prej tyre do të lëvizim? Përgjigja është do të lëvizim lokalizimin e djathtë,

nuk duhet të shqetesohemi se pse bëmë këtë veprim, do të shpjegohet me poshtë.

Pra lëvizim lokalizimin e djathtë një pozicion 2 dhe 5 janë të krahasuar kshuqë nuk nevojitet

shkëmbimi, lëvizim përpara 2 dhe 8 edhe një herë shkëmbimi nuk është i nevojshem, lëvizimi

përsëri tani lokalizimi i djathtë arrin në numrin 1, në këtë rast shkëmbimi është i nevojshëm,

ndryshojmë vëndet e elementëve me njëri-tjetrin, gjithashtu duhet ti kushtojmë vëmendje

boshtit, për çdo kalim të quicksort boshti është po i njejti element që do të thotë kur një

shkëmbim bëhet boshti duhet të lëvizi gjithashtu, duke qënë se ne filluam me boshtin në

elementin 2, tani 2 ka ndyshuar vënd boshti gjithashtu duhet të shkojë në pozicion e tij të ri ku

është elementi 2.


23

Gjithsesi lokalizimmi i majtë dhe i djathtë qëndrojnë aty ku janë duke rezultuar që boshti lëvizi

pozicionin e tij nga e majta në pozicionin e djathtë. Në rast se nuk jeni të qartë ta demostroj

dhe njëherë shembullin: lokalizimi jonë i djathtë lëvizi nga 8 tek 1, 1 dhe 2 shkëmbyen vëndet

dhe boshti lëvizi nga lokazimi i majtë në lokalizimin e djathtë. Kjo është lista jo e renditur ne

do të vazhdojmë të lëvizim, por në vënd që të lëvizim shigjetën e djathtë do të lëvizim shigjetën

e majtë.

Në këtë rast 7 > 2 aktualisht ne kemi shkëmbyer pozicion e majtë me të djathtin, ajo që do të

bëjmë tani është e kundërta, nga inspektimi në mund të themi që 7 > 2 dhe se ato janë jashtë

rendit shkëmbimi është i nevojshëm dhe çifti është i renditur, nuk duhet të harrojmë të lëvizim

boshtin pra edhe nje herë lëvizim përpara, shigjeta e djathtë shkon në elementin 4 shkëmbimi

nuk është i nevojshëm, lëviz përsëri në elementin 6 edhe një herë shkëmbimi nuk është i

nevojshëm, tani ajo që do të ndodhi është se shigjeta e djathtë do të lëvizë edhe një herë

lokalizimi i majtë, i djathtë dhe boshti ndodhen në të njëjtin element aktualisht këtu jemi në

përfundimin e kushtit, në momentin kur kemi një mbivendosje të lokalizimit të djathtë me të

majtin dhe kjo do të thotë që hapi i parë tashmë është i përfunduar.

Le të shikojmë se çfarë ka ndodhur duke qënë se lokalizimi i majtë dhe i djathtë lëvizin brënda

listës shkëmbimet janë bërë, përfundimisht lokalizimi i majtë dhe i djathtë takohen në të njëjtën

element si edhe boshti. Tani shikoni në brendësi të të gjithë listës, vërejmë që elementi 2 është

në pozicionin e tij të saktë, kur themi ne “pozicionin e tij të saktë” do të thotë se në fund kur të

kemi një listë të renditur ai është pozicioni ku ekzaktësisht elementi 2 do të gjendet. (Figura

10.2)

Figura 10.2 Përfundimi i hapit të parë Quick Sort


24

Një karakteristikë e quicksort është që në krahun e majtë të boshtit (gjithmonë pasi ka

përfunduar një hap) të gjitha elementët që ndodhen në të majtë të boshtit do të kenë një vlerë

më të vogël se boshti ndërsa elementët që ndodhen në të djathtë të boshtit janë më të mëdha se

elementi ku ndodhet boshti bashkë me lokalizimin e majtë dhe të djathtë. Një pikë tjetër që

duhet mbajtur shënim është se nëse do të ketë elementë të përsëritur (mund të ketë dy elemente

njëlloj si p.sh dy 2 ose dy 5) është e pranueshme që të vendosen në krahun e majtë por është e

rekomandueshme që të veprohet në të njëjtën mënyrë çdo herë.

Ka një pikë tjetër që lamë pezull më herët, dhe kjo është çështja, cili lokalizim është duke

lëvizur dhe çfarë drejtimi po lëviz, ju e vëreni se nga koha në kohë se si elementët janë duke

shkëmbyer vëndet dhe boshti lëviz nga pozicioni i majtë në të djathtë dhe në të kundërt.

Marrëveshja është kjo që cilido lokalizim i majti apo i djathti ka të bashkangjitur boshtin ai nuk

lëviz është lokalizmi tjetër që lëviz në lidhje me drejtimin e lëvizjes, ajo shigjetë që është e lirë

të lëvizë (pra që nuk ka poshtë saj boshtin) gjithmonë lëviz drejt elementit tjetër, është thjeshtë

se kemi dy lokalizime dhe ato lëvizin me turne në drejtim të njëri-tjetrit kur ata përfundimisht

takohen, ky është momenti ku përfundon një hap në quicksort.

Quicksort sigurisht që nuk përfundon këtu vërejmë që modeli ka ndarë të gjithë listën, në të

majtën e boshtit kemi një nën-listë jo të renditur gjithashtu edhe nga krahu i djathtë, kshuqë

cila është menyra më e lehtë për të vazhduar këtë? Se sa rekursivisht thërret quicksort, në fakt

në përfundim të hapit të quicksort ajo që ndodh është se quicksort lëviz në fillim në nën-listën

e majtë dhe më pas në nën-listën e djathtë

function quicksort

...

...

actual quicksort

...

...

perform quicksort on left sublist

perform quicksort on right sublist

end function

Në fillim

Më pas


25

Ajo që do të thotë është se ne jemi duke marë metodën përçaj dhe sundo (Divide & Qonquer

D&C) Çdo herë nën-lista bëhet e vogël dhe më e vogël dhe natyrisht një element i nën-listës

është në vetvete i renditur sepse lokalizmi i majtë, i djathtë dhe boshti janë në të njëjtin element.

Pra ne nuk kemi pse të shqetësohemi rreth saj dhe në fakt ai është rasti më i mirë (best case)

për rekursionin, le të hidhemi tek shembulli që kishim përpara

Pra kjo është lista jonë e pa renditur, ne do të thërrasim quicksort në të majtën e listës, shikojmë

që krahu i majtë i nën-listës ka vetëm një element kshuqë ne mund ta kosiderojmë atë të renditur

meqënëse sigurisht ky është rasti më i mirë (best case). (fig 10.3)

Figura 10.3 Përfundimi i hapit të dytë

Ne jemi në gjëndje për të bërë kthimin mbrapa (backtrack) të pemës së rekursivitetit dhe të

hidhemi për të renditur nën-listën në krahun e djathtë të listës origjinale, tani 6 është boshti

jonë menjëherë shkëmbimi bëhet, ne lëvizim shigjetën e majtë dhe jemi në elementin 4 nuk

është i nevojshëm shkëmbimi pasi 4<6, lëvizim përsëri jemi në elementin 7 shkëmbimi bëhet,

tani lëviz shigjeta e djathtë dhe jemi në elementin 5 edhe njëherë shkëmbimi është i nevojshëm,

lëviz shigjeta e majtë dhe jemi në elementin 8 përfundimisht shkëmbimi misdis 6 dhe 8 është i

nevojshëm, shigjeta e majtë, e djathtë dhe boshti janë në një element që është 6, do të thotë se

6 është në pozicionin e saj të saktë.

Edhe një herë hidhemi në nën-listën në krahun e majtë e cila është [3,4,5], kjo është shumë e

thjeshtë shigjeta e djathtë lëviz në drejtim të majtë dhe elementi 3 është vendosur në pozicionin

e tij të saktë, nuk ka asnjë nën-listë në të majtën e elementit 3, kshuqë hidhemi për të renditur

nën-listën në krahun e djathtë që [4,5], edhe një herë shigjeta e djathtë shkon në krahun e majtë

dhe vendos elementin 4 në pozicionin e saktë, 4 nuk ka lënë asnjë nën-listë, hidhemi direkt në

elementin 5 lokalizimi i majtë, i djathtë dhe bosht janë në të njëjtin element do të thotë që 5

është në pozicionin e duhur, 5 nuk ka nën-lista as në krahun e majtë as në kraun e djathtë pra

mund të themi që puna është kryer.

Ne bëjmë kthimin mbrapa (backtrack) në pemën e rekursionit dhe vërejmë që nën-lista tjetër

që duam të rendisim është në të djathtën e elementit 6, elementi 8 dhe 7 do bëjnë shkëmbimin

e vëndeve midis tyre kjo vendos elementin 8 në pozicionin e saktë me pas proçedojmë në anën

e majtë të nën-listes e cila është vetëm një element pra nuk ka asgjë për të bërë 7 është në

pozicionin e saj të saktë.


26

Pasi ne bëmë kthimin mbrapa (backtrack) të pemës së rekursionit për herë të fundit, ne vërejtëm

që bazikisht nuk kishim lënë nën-lista në të majtë apo në të djathtë dhe kjo do të thotë që të

gjithë hapat e quicksort kanë përfunduar, ky është Quick Sort, të gjitha hapat që u përmendet

me lart shpjegohen në (figuren 10.4).

Figura 10.4 Proçesi i renditjes së elementëve të metodës Quick Sort

Kompleksiteti i kohës, quicksort bën një krahasim minimal të elementëve, tek rasti më i mirë

(best case) i kohës së kompleksitetit është O(n log n) sepse shikon n-elemente dhe n log-kohe

dhe sigurisht log n < n prandaj ajo në fakt është më efiçent se O(n2) kompleksitet kohe, gjithsesi

fatkeqësisht në rastin e saj më të keq nëse i japim quicksort një liste jo të renditur gjithashtu do

të këtë kompleksitetin e kohës O(n2)

skenari më i mirë (best case) është O(n log n)-kohë,



27

3.1.6. Metoda: Merge Sort

Ne do të përfitojmë nga kjo sjellje e listave të renditura dhe të pa renditura me anë të metodës

që e cila quhet merge sort, gjithashtu edhe ky algoritëm bazohet në rekursion. Mergesort është

shumë i thjeshtë për tu shpjeguar ajo që algoritmi bën është e ndan të gjithë listën në nën-lista

në fakt në aq shumë nen-lista deri në momentin që elementët janë individualë (fig 11.1)

Figura 11.1 Ndarja në nën-lista deri në momentin individual MergeSort

Këto nën-lista e kanë madhësinë e tyre 1-element, ajo që ne bëjmë është e marim të gjithë listën

e parenditur dhe ndajmë atë të gjithën, ajo që do të ndodhi është se secili çift i elementëve

“komshi” do të bashkohen bashkë, mergesort mund të punojë me lista të renditura dhe me lista

te parenditura, por listat me një element në thelb janë të renditura, kur ne bashkojmë (merge)

bashkë listat me një element do marrim një listë me 2-elementë që do të jetë e renditur. Dhe do

të përsërisim këtë për çdo çift.

Ajo që ndodh tani është se kemi një tufë listash me 2 elementë që të gjitha janë të renditura, do

ta përsërisim këtë që bëmë dhe do të bashkojmë “komshijtë” listat me 2 elementë dhe ne do të

marim një tufë me lista që janë me 4 elementë që janë të renditura, duke bashkuar e ribashkuar

të gjithë listën çifte për çifte dhe përfundimisht kthehet në listën origjinale duke qënë totalisht

e renditur dhe në fakt kjo është shumë e thjeshtë. Gjithë renditja e megesort jepet në figurën

11.2


28

Figura 11.2 Renditja e elementëve Merge Sort

Objektivi që qëndron për merge sort është jashtëzakonisht i thjeshtë, e ndan të gjithe listën dhe

bashkon të gjithëm përsëri, kjo sigurisht përfiton nga rasti se si mergesort na jep neve listën e

renditur. Pra si e shkruajmë ne një kod në mergesort? Është shumë thjeshtë:

function mergesort

if size of list > 1 then

split the list into two halves

mergesort (left)

mergesort (right)

mergesort (left, right)

end if

if size of list = 1 then

do nothing

end if

end function

Në fillim ne shikojmë nëse lista ka më shumë se 1 element – ky është rasti i rekursivitetit

(if size of list > 1 then)

nëse ka e ndajmë listën në 2 pjesë (split the list into two halves)

dhe më pas thërret mergesort për secilën nga këto nën-lista,

“mergesort(left), mergesort (right)”


29

kur mergesort arrin në këtë pikë mbas çdo numri të thirrjeve të rekursivitetit çdo nën-list është

e renditur, në këtë rast thjeshtë bashkon 2 lista përsëri dhe krijon një listë të gjatë të renditur

sigurisht çdo thirrje rekursive ka nevojë për një rast të mirë (best case) për mergesort kjo ndodh

kur algoritmi thotë që nën-lista është e një madhesie 1-element.

Nuk është nevojshme të bëjmë më shumë lista pasi ajo nuk mund të ndahet më tej (if size of

list = 1 then do nothing) dhe kjo është me pak fjalë Merge Sort

Të shikojmë kompleksitetin e kohës, duhet të vëreni se si merge sort nuk ndryshon sjelljen në

varësi të të dhënave që ne i japim, për shembull nëse shikojmë quicksort të cilin e përmendëm

në metodën që kaluam quicksort varej nga përmbajtja e listës të cilën mund të bënte më shumë

ose më pak hapa ky nuk është rasti i mergesort. Mergesort e injoron plotësisht së çfarë të

dhënash ne i japim ajo thjesht e ndan të gjithë listën dhe më pas e bashkon atë.

Në të njëjtën mënyrë pavarsisht nga të dhënat që ne i japim, sigurisht mund ti japim mergesort

një listë të rastësishme dhe lista të renditura inverse ose listë të renditur, mergesort nuk i

intereson shumë, ajo thjesht e ndan të gjithë listën dhe e bashkon përsëri atë, ajo që kjo do të

thotë është rasti më i mirë dhe më i keq (best and worst case) i kompleksitetit të kohës është i

njejtë dhe ajo është O(n log n) dhe ja ku është, ky është me pak fjalë Merge Sort.

Tani nëse pyesni veten se cili është ndryshimi midis QuickSort dhe MergeSort, në shumicën e

rasteve quicksort është më i preferuar sepse në të gjithë rrugën mergesort krijon një numër

shumë të madh të rasteve të rekursivitetit, në varësi të madhësisë të listës kjo do të thotë që aty

mund të ketë shumë thirrje rekursive në vazhdim e sipër kjo sigursht na zë shumë memorje,

quicksort bën thirrje rekursiviteti atëherë kur është e nevojshme, e cila është arsyeja se në

përgjithësi quicksort përdor më pak memorje.

Ndërmjet Merge Sort dhe Quick Sort është në vazhdim e sipër se cila është më e mirë, për

opinionin tim mergesort është shume herë më e thjeshtë për tu shpjeguar ndërsa quicksort

kërkon pak kohë për tu menduar, gjithsesi ja vlen të përmendet që në shumicën e aplikacioneve

quicksort është më e preferuara.


skenari më i keq (worst case) është O(n log n)-kohë.


30

3.1.7. Metoda: Heap Sort

Duke kaluar në metodën e heapsort ne kemi dy lloje të heap:

1. MinHeap: qëndrojnë elementët e vegjël në majë

2. MaxHeap: qëndrojnë elementët e mëdha në majë

Ajo që kjo do të thotë është se në qoftë se heqim elementin në majë vazhdimisht derisa heap

(pema) të jetë bosh dhe deri sa të kemi një listë të renditur, me pak fjalë kjo është se si heapsort

funksionon. Sigurisht nuk është kaq e lehtë sa tingëllon, ne nuk duhet të largohemi nga rrënja

e pemës pasi kjo do të bëntë ndarjen e pemës në dy pemë të shkëputura gjë që ne nuk e duam

që të ndodhi (fig 12.1).

Figura 12.1 Largimi nga rrjënja sjell ndarjen në dy pemë të shkëputura HeapSort

Kështu atëherë ne duhet të bëjmë diçka pas një nxjerrje max në operacionin e nxjerrjeve min

që në fakt të krijojnë një heap (grumbull) pa e ndarë pemën në dy pjesë të shkëputura (duke

hequr rrënjën, “Emri: MaxHeap, Nxjerrja Max”, “Emri: MinHeap, Nxjerrja Min” diçka duhet

bërë pas nxjerrjeve për të rregulluar thyerjen e Heap!).

Ne do të shikojmë vetëm MinHeap, e njejta ide qëndron edhe për MaxHeap gjithashtu, le të

themi se kemi një heap si kjo (fig 12.2) unë përformoj një operacion nxjerrjeje nga rrjënja

kështu që pyetja e parë që i bëjmë vetes është: cili është kandidati më i përshtatshëm për të

zëvëndësuar rrënjën?

Figura 12.2 Përformimi i një nxjerrjeje dhe cili mund të jetë kandidati më i përshtatshëm për

rrënjën


31

Mirë ne mund të kërkojmë në pemë nga lartë poshtë për të gjetur elementin e saktë por më pas

ne do të thyenim të gjithë prioritetin e pemës kështu që më mirë të mos e bëjmë këtë. Ne do të

marim elementin e fundit të pemës dhe do ta vendosim tek rrenja, tani po mendoni qe prioriteti

është thyer do ta rregullojmë në moment, ajo që është më e rëndësishme tani është se kjo është

një pemë e plotë është një gjë e vogël për të na kujtuar se si heapsort funksionon, për çdo gjë

që ne bëjmë pëparsia jonë kryesore është të mbajmë të kompletuar prioritetin e pemës, vetëm

pasi të jemi të sigurt që nxjerrja e elementeve do të mbajë prioritetin e pemës në vënd.

Figura 12.3 Zëvëndësimi i rrjënjës duke mbajtur të kompletuar prioritetin e pemës

Kemi një element shumë të madh në rrënjën e pemës dhe ne do largojmë këtë element dhe do

të vendosim elementin e duhur, që ne ta bëjmë këtë ne përdorim një operacion që quhet sift

down, herën e fundit pamë siftup kur elementi ngjitet lart dhe tani do të bëjmë pikërisht të

kundërtën dhe kjo është siftdown

Kujtojmë se:

SiftUp

Është operacion i thjeshtë, cdo nyje duhet të shikojë prindin e tij dhe të përformoje një

krahasim me të.

Figura 12.4 Krahasimi Sift Up

SiftDown

Është pak më e vështirë pasi tani duhet ta krahasojmë kundër 2 elementëve të tjerë dhe

sigurisht do të jetë fëmija i majtë dhe i djathtë

Figura 12.5 Krahasimi Sift Down


32

Logjika pak a shumë është kështu:

procedure siftdown (Node n) // për MinHeap

if (n is a leaf) return

if (the value of n is larger than either of its children)

sawp n with the smaller of the two children

end if

end procedure

Në fillim kontrollon nëse nyja është gjethe “if (n is a leaf) return” duke qënë se nyja gjethe

nuk ka fëmijë ajo nuk e shkel prioritetin e heap dhe kështu operacioni siftdown nuk bën asgjë,

nëse ka të paktën një fëmijë ne duhet të lëvizim nëse prioriteti i heap është shkelur, për ta bërë

këtë ne duhet të krahasojmë vlerën e nyjes aktuale me fëmijën “if (the value of n is larger

than either of its children)” nëse vlera është më e vogël se të dy fëmijët e tij prioriteti i heap

nuk është i shkelur dhe nuk nevojiten më operacione siftdown,

Gjithsesi nëse prioriteti i heap është i shkelur atëherë ne duhet të vendosim se në cilin drejtim

duhet të lëvizim poshtë pra krahason më të dy fëmijët tani duke qënë se po flasim për MinHeap

këtu duhet të zgjedhim elementin më të vogël nga të dy fëmijët dhe me pas thjesht ndryshojmë

vëndet me fëmijën më të vogël “sawp n with the smaller of the two children”

Pse jo fëmijën më të madh?

Nëse ne zgjedhim femijen e madh dhe ti ndryshojmë vendet ajo që do të ndodhi është se

prioriteti i heap është akoma i shkelur (fig 12.6), kshuqë ne duhët të zgjedhim fëmijën më të

vogël nga të dy fëmijët, duke parë të tre elementët e (fig 12.7) ne kemi prioritetin e heap në

rregull.

Figura 12.6 Prioriteti është akoma i shkelur nëse zgjedhim fëmijën e madh

Figura 12.7 Duke zgjedhur fëmijën më të vogël prioriteti e kemi në rregull HeapSort


33

Sigurisht nëse ju do të përdorni maxHeap ju duhet të zgjidhni elementin më të madh nga dy

fëmijët. Kështu që lëvizim një hap poshtë nga kjo pikë është e njëjta gjë për të bërë siftup, ne

do të vazhdojmë ta bëjmë këtë deri sa të marim një pikë ku prioriteti të mos jetë më i shkelur

pra ajo që do të thotë është në momentin që ne bëjmë siftdown çfarë ndodhet në pozicion ku

ne realizojmë që të dy fëmijët janë të mëdhenj do të thotë që është pozicioni i saktë për

elementin ku duhet të jetë.

Figura 12.8 Operacioni Sift Down HeapSort

Kryesisht ajo që ne kemi bërë është se kemi lëvizur elementet më të vegjël gjatë gjithë rrugës

në majë të pemës, pra ne jemi gati për të bërë një nxjerrje min të cilën do të na dërgojë në

elementin pasardhës, i gjthë proçesi i plotë i HeapSort është të krijojmë një heap dhe të bëjmë

nxjerrje min vazhdimisht deri sa pema të jetë bosh, kjo është se si heap sort përformon.

Figura 12.9 Krijimi i një heap nga një listë jo e renditur

1

2

3

4

5

6

7

8

9


34

Ajo që bëmë në shembullin lart filluam me asgjë dhe thjeshtë krijuam heap nga lista jo e

renditur, siç mund të shohim në disa pika kemi përformuar operacionin siftup sigurisht duke

mbajtur prioritetin e heap, tani ne e kemi një heap gati ne do të bëjmë nxjerrjet min aq herë sa

është e kërkuar deri sa te marim listën e renditur.

Figura 12.10 Kthimi i heap jo i renditur që kishim më lart (fig 12.9) në listë të renditur

Ne filluam duke nxjerrë elementin 1 dhe kjo bën zhvendosjen e elementit më të vogël në majë

ajo që unë bëj këtu është ekzaktësisht e njëjta gjë për të arritur në majë të pemës duke sjellë

elementin më poshtë pemës dhe duke përformuar operacione siftdown aq herë sa na nevojiten,

siç mund të shikojmë pema ka filluar të zvogëlohet dhe ne duhet ta vazhdojmë këtë proçes

derisa heap të jetë plotësisht i boshatisur dhe në momentin që bëjmë nxjerrje min elementin e

fundit ne kemi marë listën e renditur.

Le ti shikojmë nëse HeapSort është i shpejtë apo i ngadalshëm, si gjithmonë për të bërë këtë

ne duhet të shikojmë gjithçka çfarë ndodh gjatë proçesit të HeapSort, vendos sa kohë zgjat dhe

më pas vendos të gjithë së bashku për të marë një kohë finale të kompleksitetit.

1

2

3

4

5

6

7

8

9

10 11 12


35

Le të themi se duam një listë të renditur me n-elmente gjëja e parë që do të na duhet të bëjmë

është:

1. Te ndërtojme një Heap, //sapo kemi bërë këtë

2. Duhet të përformojmë nxjerrje min n-kohë

Tani të shikojmë sa kohë zgjat çdo proçes? Sa kohë zgjat për të ndërtuar një Heap?

Koha e kërkuar për të bërë këtë është (n log n) ¿Pse është kështu? Le të themi se ne filluam

nga asgjëja dhe më pas ne patëm listën tonë origjinale jo të renditur, dhe ne vetëm vendosem

keto elemente në heap dhe sigurisht ky proçes do të përfshijë që ne filluam nga asgjeja në fillim

dhe çdo element vendosej brënda dhe do të na duhet të bëjmë një numër operacionesh siftup

dhe do të duhet ta bëjmë vazhdimisht për secilën nga elementet, sigurisht një thirrje e vetme e

sift up do të jetë log n-time

a. Të ndërtojmë një Heap,

= n * siftup // duke shumëzuar siftup me vendosjen e elementeve dhe është (n log n)

= n * log n = O(n log n)

Pse siftup kërkon log n-kohë kur kemi një element në fund të pemës dhe ne duam ti

bëjmë siftup për ta vendosur në pozicionin e saktë, nyja lëviz përgjate një dege duke

qënë se kemi një pemë të plotë aktualisht kjo nuk është aspak e ndyshme nga insertimi

i elementeve në balancimin e binarit të kërkimit në pemë, dhe kjo është pse është me e

shpejte se “n” sepse ne jemi në kërkim të elmentëve më të vegjël në n-nyje

(Siftup këtu referohet mjaftueshëm përsëritjes e siftup deri ku të vendosim elementin në

pozicionin e saktë)

Sa kohë na nevojitet për të bërë një thirrje “nxjerrje min”?

Kur ne bëjmë nxjerrje min, duke nxjerrë një element është vetem një hap por pasi kemi

bërë këtë duhet të shkëmbejmë (swap) një element lart dhe të bëjmë operacione

siftdown vështirësia për nxjerrjen min ndodh gjatë proçesit të operacionit siftdown, sa

kohë zgjat ky siftdown? Ne aktualisht e dimë përgjigjen duke përshkruar një dege si

rezultat i siftdown kërkon log n-kohe, ajo që do të thotë është nxjerrja min kërkon log

n-kohe

b. Duhet të përformojmë n-kohë të nxjerrjes min

= n * siftdown

= n * log n = O(n log n)

Lista plotësisht e renditur duke përdorur Heap ajo që do të na duhet të bëjmë është

nxjerrje min n-kohë (Siftdown këtu referohet mjaftueshëm përsëritjes e siftdown deri

kur të vendosim elementin në pozicionin e saktë) si rezultat kompleksiteti i kohës është

O(n log n)

Të shikojmë sa krahasime bëjmë në total kryesisht jemi duke bërë:

n log n + n log n = O(n log n) – krahasime // duke përdorur shenjën e madhe O ne hedhim

poshtë koefiçentin dhe si rezultat HeapSort eshte O(n log n)


skenari më i keq (worst case) është O(n log n)-kohë.


36

3.1.8. Metoda: Radix Sort

Radix sort është një nga metodat interesante për të renditur elementët sepse në fakt ky është

algoritmi i parë që nuk bën krahasime që nuk bën qasjen e zakonshme të renditjeve, shumë

shpesh në kemi parë që renditjet e algoritmeve bëjnë një grumbull të krahasimeve dhe e

perdorin atë për të vendosur elementët në rendin e duhur gjithsesi metoda që përdor radix sort

është ndryshe thjesht do të grupojë të gjithë elementet bashkë dhe do të renditen të gjithë së

bashku dhe do të grumbullojë përsëri të gjithë elementët bashkë dhe do ti rendisë përsëri të

gjithë së bashku në një listë dhe duke bërë këtë elementët përfundimisht janë të renditura, për

të kuptuar se si funksionon ky algoritëm thjesht duhet të shikoni shembujt më poshtë.

Ne do të përdorim numra të mëdha arsyea për të përdorur numra të mëdha është për efekt të

demostrimit të shembullit (radix sort nuk funksionon shumë mirë me numra të medha, për të

shfrytëzuar plotësisht metodën se si radix sort funksionon duhet të përdorim disa numra të

mëdha). Sepse radix sort thyen shifrat nga pozicioni individual, gjithashtu ju vëreni se kemi

disa numra që janë të mbushur me zero (mbushja me zero përdoret për të bërë të gjithë numrat

me 5 shifra).

Tani ajo që do të bëjmë është se do të shohim elementin më në të djathtë për çdo numër në listë

(fillojmë nga shifra më në të djathtë fig. 13.1)

Figura 13.1 Lista e pa renditur fillojmë nga elementi më në të djathtë

Në këtë pikë ajo që çfarë ne duam të bëjmë është të vendosim të gjithë bashkë elementët që

kanë vijën poshtë në të njëjtë elementë ajo që kjo do të thotë është se ju mund të përdorni

“kova” në një qasje të njëjtë për ti renditur përsëri, un do të përformoj nga e majta në të djathtë

të listës origjinale e gjitha bazohet nga nën-vijëzimi elementit, duke shkuar nga e majta në të

djathtë unë nuk jam duke i thyer pozicionet relative të elementeve në të njëjtën “kove” pra tani

un kam gjithçka në “koven” e duhur (këtë e shpjegon figura 13.2).

Figura 13.2 Vendosja e elementëve në “kovat”e duhura sipas nënvizimit të numrit Radix Sort


37

Ajo që do të bej tani do të nxjerr të gjithë elementet jashtë por duke e bërë këtë sipas rendit të

“kovave”

Figura 13.3 Nxjerrja e elementëve sipas rendit të “kovave” Radix Sort

Ne fillojmë me “koven” 0 nxjerrim elementin dhe e vendosim në listë dhe më pas në koven 1,2

dhe me radhë deri në fund, në thelb ajo që bëra grumbullova listën origjjinale me disa

ndryshime, grupimi është i bazuar në nënvijëzimin e shifrave ky është hapi i parë i radix sort.

Tani do lëviz përpara nën-vijëzimin në shifrën e dytë dhe do të bëjmë të njëjtat hapa

Figura 13.4 Përfundimi i hapit të 2-të Radix Sort

Ne krijojmë “kovat” tona si gjithmonë sipas shifrave të nën-vijëzuara por këtu jemi në shifrën

e dytë, ne momentin që kovat mbushen i nxjerrim përsëri përjashta duke i grumbullar në listën

origjinale dhe ne mund të lëvizim në shifrën tjetër të radix, edhe një herë vendosim të gjithë të

nën-vijëzuarat duke filluar nga e majta në të djathtë duke i vendosur në kovat individuale dhe

i nxjerrim përsëri përjashta.


38



Figura 13.7 Përfundimi I hapit të 5-të ku lista është e renditur Radix Sort


39

Në momentin që shkuam tek elementi i fundit ne shkojmë nga e majta në të djathtë grupojmë

të gjithë elementët tek kovat dhe më pas i nxjerrim përsëri jashtë po në ketë rast duke qënë se

është hapi i fundit lista vjen e renditur.

Në fakt ne këtë e bëmë duke mos bërë asnjë krahasim të vetëm midis elementëve individual në

listë, të gjithë renditjet e algoritmave që kemi parë deri tani të gjithë njihen si algoritmet e

krahasimeve sigurisht asyea është evidente ne krahasojmë elementët me njëri-tjetrin, radix sort

nuk është një algoritëm krahasues në sensin që nuk bëhën krahasime midis elementeve në listë

nësë do të shikoni se sa kohë kërkon do të vërejmë se është pak kohë.

Sigurisht jemi të aftë për të njohur se ne jemi duke kërkuar për n-elementë vazhdimisht por sa

herë saktësisht, ne fakt ne shikojmë në këtë aq herë sa shifra ka numëri (një kalim për çdo shifër

5-shifra = 5-hapa)

Kjo do të thotë që koha e kompleksitetit të radix sort është O(kn)

k – numri i shifrave të një numri të gjatë (në shifra të shumta)

n – sigurisht si gjithmone n i referohet numrit të elementëve në listë

Ne tani mund të themi që: hey po nuk bie poshtë koefiçenti duke përdorur simbolin e O së

madhe problemi qëndron se në radix sort nuk e dimë se sa i madh mund të jetë “K”, duke u

varur nga madhësia në disa raste k nuk është e madhe (nëse k është në mënyrë të

konsiderueshme e vogël O(k) = O(n) ) kjo do të thotë që në disa raste radix sort mund të jetë

shumë e shpejtë në sensin që k mund të jetë e vogël dhe është O(n) (ne nuk e dimë nëse k ose

n është e madhe, kështu që ne i mbajme të dyja) gjithsesi “k” mund të jetë shumë e madhe dhe

në fakt ndonjëherë radix sort mund të jetë më i ngadaltë se algoritmet krahasuese.

Implementimi i radix sort është i njohur si rendësia e shifrës së fundit (Least significant digit

LSD) Radix Sort, arsyea se pse është quajtur kështu sepse sigurisht ne lëvizëm nga shifra më

në të djathtë e deri tek shifra në të majtë p.sh. numri 07125 dhe 5 eshte shifra e fundit (Least

significant digit LSD) me pak fjalë ne filluam nga (LSD)


40

3.1.9. Metoda: Shell Sort

Shell sort është shumë e ngjashme me insertion sort diferenca është se shell sort ka disa

funksione të reja që do të përmisojnë përformancën ndërkohë në të njëjtën kohë është shumë i

thjeshtë për tu përdorur. Ndërkohë që insertion sort është shumë i shpejtë nëse është një liste e

renditur problemet mund të ndodhin nëse një element i vogël mund të jetë shumë larg në krahun

e djathtë dhe arsyea është sepse të gjithë elementet në atë situatë kanë nevojë për shkëmbim në

listë duke lëvizur elementët e vogëla nga e djathta në të majtë.

Shell sort e rregullon këtë problem duke i renditur pjesërisht elementët në listë për më tepër le

të shikojmë shembullin për të patur një ide më të qartë (fig 14.1)

Vërejmë që lista e pa renditur përmban 8 elementë, formula e shell sort në cilën operon ky

algoritëm është:

n-elementë = 8,

k = n/2

k = 8/2 = 4,

pra ne do të krahasojmë elementin e 0 me 4, 1 me 5, 2 me 6, 3 me 7, 4 me 8, dhe këtu përfundon

hapi i parë i algoritmit, gjithmonë duke pasur parasysh se elementët më të vogëla duhet të

ndodhen në të majtë të listës dhe elementët e mëdha në krahun e djathtë të listës.

Figura 14.1 Përfundimi i hapit të 1-rë i algoritmit shell sort

Më pas algoritmi në hapin e dytë do të përfomojë sigurisht n = 4 dhe k=4/2=2 siç është figurën

meposhtë


41

Figura 14.2 Përfundimi i algoritmit duke përdorur k=4/2=2 Shell Sort

Figura 14.3 Përdorimi i k=2/2=1 dhe marin listën e renditur Shell Sort

Kompleksiteti i kohës së shell sort është i njëjtë me atë të insertion sort gjithsesi edhe shell sort

ka një rast të mirë (best case) të kohës së kompleksitetit dhe kjo vjen fare natyrshëm nëse e

shikoni mënyrën se si është algoritmi në vetvete sepse nëse ne do ti japim metodës shell sort

një listë të renditur, çdo element ku janë shigjetat poshtë do të shkojë nga “komshiu” në të

majtë vetëm një herë dhe thotë: oh hey un jam në pozicion, shigjeta do të lëvizë tek elementi

tjetër elementi do shikojë përsëri te “komshiu” në të majtë dhe të japë të njëjtën përgjigjë: oh

hey un jam në pozicion, dhe kjo do përsëritet për çdo element që është në listë që do rezultojë

në një total të madh të O(n)

Dhe e anasjellta nëse ne do ti japim shell sort një listë të parenditur kostoja e kohës së

kompleksitetit do të jetë O(n2)




42

4.1. Rendësia e algoritmeve të renditjes në manaxhimin e të dhënave

Në jetën reale ne pa e kuptuar përdorim algoritme për të renditur shumë gjera të ndryshme

rastet janë të shumta p.sh. ¿A kemi parë ndonjëherë që një pedagog të alfabetizojë një sasi të

caktuar të fletoreve të provimit? ¿Në thelb ky është një problem renditjeje, apo jo? Gjatë kësaj

kohe kam analizuar dhe pyetur njerëz se si ato i alfabetizonin dokumentat, qoftë edhe ato

dokumenta në mënyrë abstrakte.

Si e bën renditjen e algorimeve pedagogu? Pothuajse gjithmonë, vendosin emrat me “A” në

fillim më pas më “B” dhe kështu e në vazhdim por algoritmi është pothuajse gjithmonë njëlloj.

Pasi pedagogu e bën këtë, ¿çfarë do të bëjë më pas? Pedagogu fillon me vlerësimin e të githëve

studentëve ose mund të ndodhi e kundërta që në fillim mund të bëjë vlerësimin dhe më pas të

perdorë algoritmin për renditjen e tyre, në experiencën që kam hasur duke pyetur, shumica e

pedagogëve përdorin algoritmin e Insertion Sort.

Të gjithë e dimë se quicksort është menyra më e mirë dhe më shpejtë për zgjidhjen, ¿Përse

pedagogët nuk perdorin quicksort? Pergjigja ime për këtë pyetje është sepse ndryshe nga

komjuterat truri i njeriut nuk mund të bëjë krahasime në të njëjtën mënyrë si kompjuteri, siç e

dimë truri i njeriut nuk mund të meret më sasi të mëdha të dhënash,

Rendësia e mbajtjes së të dhënave në formë të renditur ka disa avantazhe

Kërkimi bëhet më i thjeshtë edhe nëse mund të kemi sasi të mëdha të dhënash

Mund të shtojmë, të eliminojmë, të përditsojmë të dhënat më thjeshtë

Raportet janë të renditura në një mënyrë më efiçente

Eksperimentet janë të rendësishme për çdo pjesë të shkencës kompjuterike, gjithashtu edhe në

ekonomi. Aftësia për të bërë ekperimente në mjedise laboratorike ofron njohuri që nuk mund

të studiohen lehtë në jetën reale. Struktura eksperimentale lejon që ti përgjigjet pyetjes “po

nëse”. Ështe e paqartë se si rezultatet e eksperimenteve laboratorike mund të aplikohen në jetën

reale. Për shembull të vlerësojme trajtimin e efekteve në një mjedis bazë. Por kjo është një

dobësi në aspektin e zbatueshmërisë në jetën reale.

Në laborator subjektet janë të mbyllura në mjedise ekperimentale dhe janë të detyruar që tu

luajnë lojën që i paraqitet, por marketet veprojnë ndryshe në market renditja individuale

bazohet në preferencat dhe aftësitë e tyre. Aftësia për të renditur do të thotë se ne nuk mund të

nxjerrim konkluzione të drejtpërdrejta në lidhje me rendësinë e reagimit të sjelljes ndaj

trajtimeve eksperimentale për jetën reale.


43

Për shembull nje eksperimet që i drejohet individëve të zgjedhur rastësisht mund te zbulojnë

se një pjesë e madhe mund të vuajnë nga frika e lartësisë, por renditja dhe zgjedhja vullnetare

të siguruar nga ato që ndërtojnë ndërtesa të larta ka gjasa që të jenë në mesin e atyre që vuajnë

nga lartësitë. Premiumi i pagave reflekton nga preferencat e individit jo nga mesatarja e

individuale e popullsisë.

Në qoftëse ka një numër të mjaftueshëm të punëtorëve që nuk vuajnë nga lartësitë nuk do të

ketë premium të pagave që punojnë në lartësi. Mund të ketë shumë njerëz të cilët kërkojnë një

çmim shumë të lartë për të punuar në lartësi. Por pjesa e sipërme e kurbës së ofertës mund të

jetë krejtësisht e pa rendësishme.

Është po aq e mundur që renditja përkeqëson efektin. Vetëbesim për shembull mund të jetë një

tipar i rrallë në popullsinë e përgjithshmë, por ata që nënshkruhen në anëtarësimin e klubin e

shëndetësor mund të jenë vecantërisht të prirur për mbivlerësim të vetëkontrollit të tyre, i cili

do të shpjegojë shkallën e ulët mesatare të pjesëmarrjes së anëtarve të cilët paguajnë tarifë ta

lartë mujore.

Të dy shembujt shembujt ilustrojnë fuqinë e renditjes, eksperimentet që nuk lejojnë renditjen

përshkruaj preferencat e një individi mesatar dhe jo të një individi marxhinal, sjellja e të cilit

është e rëndësishmë për përcaktimin e çmimeve dhe rezultateve. Nëse rezultet e një

eksperimenti mbivlerësojnë ose nënvlerësojnë atë që është vërejtur në market varet nga

marëdhënja e preferencave të individit marxhinal ndaj atyre të individit mesatar. Ne ofrojmë

rezultatet e një eksperimenti i cili tregon rendësinë e një fenomeni të caktuar, përkatësisht

ndarjen në mungesë të rënditjës është e kunderta kur renditja lejohet


44

5.1. Renditja e algoritmeve në JAVA (Aplikacioni)

Qëllimi jonë për të gjithë sa shpjeguam më lart ishte që ta implementonim zhivillimin e

renditjeve të algoritmeve në një framework IDE (Integrated Development Environment)

NetBeans në të cilën ne mund të shikonim funksionimin e tyre në mënyre virtuale. Do të

shikojmë situata të ndryshme që janë të rendësishme në aplikacionin e renditjeve të algoritmeve

5.2. Klasat përgjegjëse për ndërtimin e aplikacionit

Në doni më shumë informacion rreth implementimit të algoritmeve në programimin Java

kontaktoni në: [email protected]

6.1. Biblografia

http://rob-bell.net/2009/06/a-beginners-guide-to-big-o-notation/

http://en.wikipedia.org/wiki/Big_O_notation

http://en.wikipedia.org/wiki/Time_complexity

http://en.wikipedia.org/wiki/Comparison_sort

http://www.c-sharpcorner.com/UploadFile/fd0172/radix-sort-in-java/

https://en.wikipedia.org/wiki/Selection_sort

https://en.wikipedia.org/wiki/Bubble_sort

https://en.wikipedia.org/wiki/Cocktail_shaker_sort

https://en.wikipedia.org/wiki/Insertion_sort

https://en.wikipedia.org/wiki/Quicksort

https://en.wikipedia.org/wiki/Merge_sort

https://en.wikipedia.org/wiki/Heapsort

https://en.wikipedia.org/wiki/Radix_sort

https://en.wikipedia.org/wiki/Shellsort

Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. Introduction

to Algorithms. McGraw-Hill, 2nd edition, 2001.

Anany Levitin. Introduction to The Design & Analysis of Algorithms. Addison Wesley, 2nd

edition, 2007


45

The 1993 article by McIlroy, Bostic, and McIlroy presents the state of the art in radix sort

implementations.

R. Baeza-Yates and G. H. Gonnet, Handbook of Algorithms and Data Structures, second

edition, Addison-Wesley, Reading, MA, 1984.

J. L. Bentley and M. D. McIlroy, "Engineering a sort function," Software—Practice and

Experience 23, 1 (January, 1993).

J. L. Bentley and R. Sedgewick, "Sorting and searching strings," Eighth Symposium on

Discrete Algorithms, New Orleans, January, 1997.

M. L. Fredman, R. Sedgewick, D. D. Sleator, and R. E. Tarjan, "The pairing heap: a new form

of self-adjusting heap," Algorithmica 1, 1 (1986).

P. Hildebrandt and H. Isbitz, "Radix exchange — an internal sorting method for digital

computers," Journal of the ACM, 6, 2 (1959).

C. A. R. Hoare, "Quicksort," Computer Journal, 5, 1 (1962).

D. E. Knuth, The Art of Computer Programming. Volume 3: Sorting and Searching, second

edition, Addison-Wesley, Reading, MA, 1997.

P. M. McIlroy, K. Bostic, and M. D. McIlroy, "Engineering radix sort," Computing Systems

6, 1 (1993).

R. L. Rivest and D. E. Knuth, "Computing Sorting," Computing Reviews, 13 6 (June, 1972).

R. Sedgewick, "Implementing quicksort programs," Communications of the ACM 21, 10

(October 1978).

R. Sedgewick, "Analysis of shellsort and related algorithms," Fourth European Symposium on

Algorithms, Barcelona, September, 1996.

Astrachan, O. Bubble sort: an archaeological algorithmic analysis. SIGCSE Bull. 35, 1–5

(2003).

Edjlal, R., Edjlal, A. & Moradi, T. A sort implementation comparing with Bubble sort and

Selection sort. ICCRD2011 - 2011 3rd Int. Conf. Comput. Res. Dev. 4, 380–381 (2011).

Harris, J. D. Sorting unsorted and partially sorted lists using the natural merge sort. Softw.

Pract. Exp. 11, 1339–1340 (1981).

Musser, D. R. Introspective Sorting and Selection Algorithms. Softw. Pract. Exp. 27, 983–993

(1997).

Documents

Një studim krahasues mbi renditjen e algoritmave dhe ...gazmend-suparaku.com/wp-content/uploads/2016/03/Gazmend-Suparaku-Teme... · republika e shqipËrisË universiteti i elbasanit