Begreber og Redskaber 7

Plan for idag Sorteringsalgoritmer Logaritmer,tabeller,køretid Simpelt iterativt: udvalgssortering Rekursivt: Flette sortering Budskab: Køretid kan være et problem og bør løses med bedre algoritmer

Logaritmer Det omvendte af potenser 10 5 = =1 log 10 (100000)=5log 10 (1)=0 2 8 = =1 log 2 (256)=8log 2 (1)=0 Regne med potenser og logaritmer a n+m =a n * a m log(n * m)=log(n)+log(m)

Logaritmer Hvor mange gange skal man knække et 256 meter langt rør midt over for at få et 1 meter langt stykke? Du tænker på et tal mellem 1 og 256. Hvor mange ja/nej skal jeg stille for at gætte det?

Tabeller/Arrays int[] tabel = new tabel[100]; tabel[0]=1; tabel[99]=117; for(int i=0;i<tabel.length;i++) tabel[i]=i*29; Erklæring, konstruktion, initialisering

Tabeller Underprogrammer static void fill(int[] t, int v){ for(int i=0;i<t.length;i++)t[i]=v; }... main(…){ int[] tabel=new int[100]; fill(tabel,23); int[] tabel1=new int[10000]; fill(tabel1,0); }

Køretid static void fill(int[] t, int v){ for(int i=0;i<t.length;i++)t[i]=v; } Køretid proportional med længden af tabellen – jo større tabel, jo længere tid tager det. O(n) hvor n er størrelsen af inddata Eksempler: O(n 2 )O(2 n )O(n log(n))

Sortering En vilkårlig liste af heltal [11, 9, 17, 5, 12] ønskes sorteret [5, 9, 11, 12, 17]

Udvalgssortering Det mindste element og det forreste element [11, 9, 17, 5, 12] ombyttes. I den resulterende liste [5, 9, 17, 11, 12] er det forreste element korrekt placeret [5, 9, 17, 11, 12] Sådan fortsættes

Udvalgssortering [11, 9, 17, 5, 12] [5, 9, 17, 11, 12] [5, 9, 11, 17, 12] [5, 9, 11, 12, 17]

Udvalgssortering public static void sort(int[] a){ for (int i=0; i<a.length-1; i++){ int minPos = minimumPosition(a,i); if (minPos!=i){ int temp = a[minPos]; a[minPos] = a[i]; a[i] = temp; }

Hjælpeprogram til udvalgssortering public static int minimumPosition(int[] a, int from){ int minPos = from; for (int i=from+1; i<a.length; i++) if (a[i]<a[minPos]) minPos = i; return minPos; }

Figure 1 Time Taken by Selection Sort Bemærk køretid bliver hastigt lang for store tabeller

Køretid for udvalgssortering Husk public static void sort(int[] a){ for (int i=0; i<a.length-1; i++){ int minPos = minimumPosition(a,i);... public static int minimumPosition(int[] a, int from){ for (int i=from+1; i<a.length; i++)... Groft overslag: Lad n være a.length. for-løkke i sort gennemløbes ca n-gange. Hver gang kaldes minimumPosition der har optil n gennemløb. Altså n * n gennemløb eller O(n 2 )

Lidt mere præcist Første gang minimumPosition kaldes er der n-1 gennemløb, anden gang n-2 gennemløb, osv (n-1)+(n-2)+(n-3)+…+1 = n * (n-1) * 0.5 ca = n 2 altså O(n 2 )

Fletning Flettesortering De to lister [5, 9, 10] og [1, 8, 11] er begge sorterede En samlet og sorteret liste [1, 5, 8, 9, 10, 11] ønskes. En sådan kan fås vha. sammenfletning

Fletning De to lister flettes sammen på følgende vis [] <- [5, 9, 10] [1, 8, 11] [1] <- [5, 9, 10] [8, 11] [1, 5] <- [9, 10] [8, 11] [1, 5, 8] <- [9, 10] [11] [1, 5, 8, 9] <- [10] [11] [1, 5, 8, 9, 10] <- [] [11] [1, 5, 8, 9, 10, 11] <- [] []

Flettesortering Flettesortering af en liste heltal Der er to tilfælde 1. Listen har eet element -- Der skal da ikke gøres noget 2. Listen har mere end eet element -- Listen deles op i to mindre lister -- Hver af de to mindre lister flettesorteres -- De to resulterende lister flettes sammen Bemærk: Basis og rekursivt tilfælde

Fletning from mid mid+1 to Sorteret

Fletning static void merge(int[] tb,int[] tm, int from,int mid,int to){ int n = to-from+1; int i1=from, i2=mid+1, j=0; while(i1<=mid && i2 <= to){ if(tb[i1]<tb[i2]){ tm[j]=tb[i1];i1++;j++; }else{ tm[j]=tb[i2];i2++;j++; } while(i1<=mid){tm[j]=tb[i1]; i1++;j++;} while(i2<=to ){tm[j]=tb[i2]; i2++;j++;} for(j=0;j<n;j++)tb[from+j]=tm[j]; }

Flettesortering static void mergesort(int[] tb,int[] tm, int from,int to){ if(from==to) return; int mid=(to+from)/2; mergesort(tb,tm,from,mid); mergesort(tb,tm,mid+1,to); merge(tb,tm,from,mid,to); } static void sort(int[] tb){ int tm[]=new int[tb.length]; mergesort(tb,tm,0,tb.length-1); }

Figure 2 Merge Sort Timing (Rectangles) versus Selection Sort (Circles)

Køretid – groft overslag Ide: halver tabel – sorter hver del og flet. Fletning er i lineær tid (dvs n), men hvor mange gange kan man halvere en tabel? Lad n være tabellens længde. Køretid i størrelsesordenen n * log 2 (n)

Køretid For merge(.. from,mid,to) gennemløbes elementerne fra ”from” til ”to” 2 gange Køretid af mergesort: T(n) = T(n/2)+T(n/2)+2 * n = 2 * (T(n/2)+n) udfold: T(n)=2*(2*(T(n/4)+n/2)+n) T(n)=2*(2*(2*(T(n/8)+n/4)+n/2)+n)

Køretid T(n)=2*(2*(T(n/4)+n/2)+n) =4*T(n/4)+4*n T(n)=2*(4*T(n/8)+4*n/2)+n)=8*T(n/8)+6*n T(n)=2*(8*T(n/16)+6*n/2)+n)=16*T(n/16)+8*n T(n)=2 k +2*k*n, hvor k er antal gange man kan halvere – altså log 2 (n) O(log 2 (n) * n)

Eksempel Antal sammenligninger (<): Tabel med 1000 udvalgssortering: Flettesortering:8706 Tabel med udvalgssortering: Flettesortering:120472

Konklusion Det at funktionen n·log(n) vokser mindre end funktionen n 2 forklarer hvorfor det er mere effektivt at flettesortere end at udvalgssortere.