Kap 02 Tabeller / Tabelloperasjoner

Enkeltvariable Les inn nedbørmengde for årets 12 måneder: Les n1 Les n2 … Les n12 n1 n2 n12

Array Les inn nedbørmengde for årets 12 måneder: FOR mnd := 1 TO 12 les nedbor[mnd] ENDFOR nedbor nedbor[2] FOR mnd := januar TO desember les nedbor[mnd] ENDFOR

Attributter Funksjoner Array / Struct / Class ArrayStructClass

class Behandle nedbørmengde for årets 12 måneder: class Nebor { private: data[12] public: Nedbor(…) setNedbor(…) getNedbor(mnd) sum( ) gjennomsnitt( ) getMax( ) getMin( ) … }

Søkemetoder - Lineær søking -Stegvis søking -Binær søking

Lineær søking - Strategi Tabellen trenger ikke være sortert. Søker fortløpende fra begynnelsen av tabellen inntil søkt post er funnet eller vi finner ut at søkt post ikke finnes. Søkt post

Lineær søking Algoritme 1 LinSok (tab,max,sid) /*Rutinen søker lineært etter gitt post i en tabell*/ /*og returnerer med nr = tabellposisjon til funnet post.*/ /*Hvis posten ikke finnes, returneres 0.*/ /*tab:Tabellen hvor søkingen skal foregå*/ /*max:Maksimalt antall elementer i tabellen*/ /*sid:Verdien til søkt Id*/ nr:=0 n :=1 WHILE (nr = 0) AND (n<=max) DO IF sid = tab[n]THEN nr:=n ELSE n:=n + 1 ENDIF ENDWHILE Return nr

Lineær søking Algoritme 2 LinSok (tab,max,sid) /*Rutinen søker lineært etter gitt post i en tabell*/ /*og returnerer med nr = tabellposisjon til funnet post.*/ /*Hvis posten ikke finnes, returneres 0.*/ /*tab:Tabellen hvor søkingen skal foregå*/ /*max:Maksimalt antall elementer i tabellen*/ /*sid:Verdien til søkt Id*/ n :=1 WHILE (n tab[n]) DO n:=n + 1 ENDWHILE IF n <= max THEN nr := n ELSE nr := 0 Return nr

Lineær søking Antall aksesser Maksimalt antall aksesser: Gjennomsnittlig antall aksesser:

Stegvis søking - Strategi Tabellen må være sortert. Søker fra begynnelsen i sprang inntil vi har kommet tilstrekkelig langt. Søker eventuelt innenfor siste sprang. Søkt post

Stegvis søking Antall aksesser 1 Maksimalt antall aksesser:

Stegvis søking Antall aksesser 2 Gjennomsnittlig antall aksesser: Optimal steglengde: Gjennomsnittlig antall aksesser ved optimal steglengde:

Stegvis søking Algoritme StegSok (tab,max,sid) /*Rutinen søker stegvis etter gitt post i en tabell*/ /*og returnerer med nr = tabellposisjon til funnet post.*/ /*Hvis posten ikke finnes, returneres 0.*/ /*tab:Tabellen hvor søkingen skal foregå*/ /*max:Maksimalt antall elementer i tabellen*/ /*sid:Verdien til søkt Id*/ nr:=0 x:=Sqrt(max) forst:=1 sist:=max forrige:=forst WHILE (forst < sist) AND (tab[forst] < sid) DO// sprang forrige:= forst forst:= minst(forst+x,sist) ENDWHILE i := forst IF sid <> tab[i] THEN i := forrige WHILE (i < forst) AND (tab[i] < sid) DO// lineært i := i + 1 ENDWHILE ENDIF IF sid = tab[i] THEN nr := i ENDIF Return nr

Binær søking - Strategi Tabellen må være sortert. Halverer fortløpende og søker videre i aktuell halvdel. Søker inntil søkt post er funnet eller vi kun har en post igjen.

Binær søking Antall aksesser Antall poster i tabellen:N Etter 1 halvering har vi igjen :N/2 =N/2 1 poster Etter 2 halveringerhar vi igjen :N/4 =N/2 2 poster Etter 3 halveringerhar vi igjen :N/8 =N/2 3 poster Etter Ahalveringer har vi igjen :N/2 A poster Maksimalt antall aksesser: Gjennomsnittlig antall aksesser:

Binær søking Algoritme 1 BinSok (tab,max,sid) /*Rutinen søker binært etter gitt post i en tabell*/ /*og returnerer med nr = tabellposisjon til funnet post.*/ /*Hvis posten ikke finnes, returneres 0.*/ /*tab:Tabellen hvor søkingen skal foregå*/ /*max:Maksimalt antall elementer i tabellen*/ /*sid:Verdien til søkt Id*/ nr:=0 forst:=1 sist:=max mid:=(forst+sist) DIV 2 WHILE (sid <> tab[mid]) AND (forst < sist) DO IF sid < tab[mid] THEN sist := mid - 1 ELSE forst := mid + 1 ENDIF mid := (forst + sist) DIV 2 ENDWHILE IF sid = tab[mid] THEN nr := mid ENDIF Return nr

Binær søking Algoritme 2 BinSok (tab,forst,sist,sid) /*Rutinen søker binært etter gitt post i en tabell*/ /*og returnerer med nr = tabellposisjon til funnet post.*/ /*Hvis posten ikke finnes, returneres 0.*/ /*Søkingen er rukursiv.*/ /*tab:Tabellen hvor søkingen skal foregå*/ /*forst:Peker (indeks) til første element*/ /*sist:Peker (indeks) til siste element*/ /*sid:Verdien til søkt Id*/ mid:=(forst+sist) DIV 2 IF forst > sist THEN Return 0 ELSEIF sid = tab[mid] THEN Return mid ELSEIF sid < tab[mid] THEN Return BinSok(tab,forst,mid-1,sid) ELSE Return BinSok(tab,mid+1,sist,sid) ENDIF

Søkemetoder - Oppsummering (1/2) Lineær søking Stegvis søking Binær søking

Søkemetoder - Oppsummering (2/2) Lineær søking Stegvis søking Binær søking N = 2 millioner

Sortering Ofte er det ønskelig å kunne gi data-elementene en viss ordning eller struktur, dette for raskere / enklere å kunne behandle disse dataene og/eller med tanke på fremtidig anvendelse. En form for ordning er sortering.

Sorterings-metoder - Boblesortering -Bucketsort -Shellsort - Quicksort -...

Boblesortering - Eksempel (1) * * * *

* Boblesortering - Eksempel (2)

* Boblesortering - Eksempel (3)

* Boblesortering - Eksempel (4)

Boblesortering - Algoritme 1 BSort (tab,n) /*Rutinen sorterer tabeller vha boblesortering*/ /*tab:Tabellen som skal sorteres*/ /*n:Maksimalt antall elementer i tabellen*/ bytt:= true j:= 1 WHILE bytt DO bytt := false FOR i:=1 TO n-j DO IF tab[i] > tab[i+1] THEN bytt:=true x:=tab[i] tab[i]:=tab[i+1] tab[i+1]:=x ENDIF ENDFOR j := j + 1 ENDWHILE

Boblesortering - Algoritme 2 BSort (tabId,tabDt,n) /*Rutinen sorterer tabeller vha boblesortering*/ /*tabId:Tabellen som inneholder sorteringsnøkkelen*/ /*tabDt:Tabellen(e) som inneholder resterende data*/ /*n:Maksimalt antall elementer i tabellen*/ bytt:= true j:= 1 WHILE bytt DO bytt := false FOR i:=1 TO n-j DO IF tabId[i] > tabId[i+1] THEN bytt := true x:=tabId[i] tabId[i]:=tabId[i+1] tabId[i+1]:= x y:=tabDt[i] tabDt[i]:=tabDt[i+1] tabDt[i+1]:= y ENDIF ENDFOR j := j + 1 ENDWHILE Nilsen Olsen Hansen Knutsen Persen tabIdtabDt

Boblesortering - Algoritme 3 BSort (tab,n) /*Rutinen sorterer tabeller vha boblesortering*/ /*tab:Tabellen som inneholder sorteringsnøkkelen*/ /*n:Maksimalt antall elementer i tabellen*/ bytt:= true j:= 1 WHILE bytt DO bytt := false FOR i:=1 TO n-j DO IF tab[i].id > tab[i+1].id THEN bytt := true x:=tab[i] tab[i]:=tab[i+1] tab[i+1]:= x ENDIF ENDFOR j := j + 1 ENDWHILE Nilsen Olsen Hansen Knutsen Persen iddt

Ordentabeller Ved sortering av store/mange tabeller, kan vår opprinnelige boblesorteringsmetode medføre flytting av store datamengder. En forbedring kan utføres vha av en såkalt ordentabell. Ordentabellen leses sekvensielt forfra og indikerer i hvilken rekkefølge tabellen(e) skal leses. Før sorteringEtter sortering

Boblesortering vha ordentabell BSort (tab,orden,n) /*Rutinen sorterer tabeller vha boblesortering*/ /*tab:Tabellen som skal sorteres*/ /*orden:Ordentabell*/ /*n:Maksimalt antall elementer i tabellen*/ bytt:= true i:= 1 WHILE bytt DO bytt := false FOR i:=1 TO n-j DO IF tab[orden[i]] > tab[orden[i+1]] THEN bytt:=true x:=orden[i] orden[i]:=orden[i+1] orden[i+1]:=x ENDIF ENDFOR j := j + 1 ENDWHILE

Innsetting / Sletting i tabeller Innsetting Sletting

Innsetting i tabell - Algoritme Innsett (tab,max,n,nyPost,pos,flag) /*Rutinen setter inn ny post i en tabell*/ /*tab:Tabellen hvor ny post skal innsettes*/ /*max:Maksimalt antall plasser i tabellen tab*/ /*n:Første ledige posisjon i tabellen tab*/ /*nyPost:Ny post som skal innsettes*/ /*pos:Posisjon i tab hvor ny post skal innsettes*/ /*flag:Returnerer true hvis innsetting ok*/ IF n > max THEN flag := false ELSE flag:= true i:= n - 1 WHILE i >= pos DO tab[i+1]:= tab[i] i:= i - 1 ENDWHILE tab[pos]:= nyPost n := n + 1 ENDIF

Sletting i tabell - Algoritme Slett (tab,n,pos) /*Rutinen sletter en post i en tabell*/ /*tab:Tabellen hvor post skal slettes*/ /*n:Første ledige posisjon i tabellen tab*/ /*pos:Posisjon i tab hvor post skal slettes*/ i := pos WHILE i < n-1 DO tab[i]:= tab[i+1] i:= i + 1 ENDWHILE n := n - 1

Henting i tabell - Algoritme Hent (tab,n,pos,post) /*Rutinen henter og sletter en post i en tabell*/ /*tab:Tabellen hvor post skal slettes*/ /*n:Første ledige posisjon i tabellen tab*/ /*pos:Posisjon i tab hvor post skal slettes*/ /*post:Returnerer med post som skal slettes*/ post := tab[pos] Slett(tab,n,pos)

ENDEND