Præsentation er lastning. Vent venligst

Præsentation er lastning. Vent venligst

Begreber og Redskaber 7. Plan for idag Sorteringsalgoritmer Logaritmer,tabeller,køretid Simpelt iterativt: udvalgssortering Rekursivt: Flette sortering.

Lignende præsentationer


Præsentationer af emnet: "Begreber og Redskaber 7. Plan for idag Sorteringsalgoritmer Logaritmer,tabeller,køretid Simpelt iterativt: udvalgssortering Rekursivt: Flette sortering."— Præsentationens transcript:

1 Begreber og Redskaber 7

2 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

3 Logaritmer Det omvendte af potenser 10 5 =10000010 0 =1 log 10 (100000)=5log 10 (1)=0 2 8 =2562 0 =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)

4 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?

5 Tabeller/Arrays int[] tabel = new tabel[100]; tabel[0]=1; tabel[99]=117; for(int i=0;i { "@context": "http://schema.org", "@type": "ImageObject", "contentUrl": "http://images.slideplayer.dk/9/2652783/slides/slide_5.jpg", "name": "Tabeller/Arrays int[] tabel = new tabel[100]; tabel[0]=1; tabel[99]=117; for(int i=0;i

6 Tabeller Underprogrammer static void fill(int[] t, int v){ for(int i=0;i { "@context": "http://schema.org", "@type": "ImageObject", "contentUrl": "http://images.slideplayer.dk/9/2652783/slides/slide_6.jpg", "name": "Tabeller Underprogrammer static void fill(int[] t, int v){ for(int i=0;i

7 Køretid static void fill(int[] t, int v){ for(int i=0;i { "@context": "http://schema.org", "@type": "ImageObject", "contentUrl": "http://images.slideplayer.dk/9/2652783/slides/slide_7.jpg", "name": "Køretid static void fill(int[] t, int v){ for(int i=0;i

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

9 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

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

11 Udvalgssortering public static void sort(int[] a){ for (int i=0; i { "@context": "http://schema.org", "@type": "ImageObject", "contentUrl": "http://images.slideplayer.dk/9/2652783/slides/slide_11.jpg", "name": "Udvalgssortering public static void sort(int[] a){ for (int i=0; i

12 Hjælpeprogram til udvalgssortering public static int minimumPosition(int[] a, int from){ int minPos = from; for (int i=from+1; i { "@context": "http://schema.org", "@type": "ImageObject", "contentUrl": "http://images.slideplayer.dk/9/2652783/slides/slide_12.jpg", "name": "Hjælpeprogram til udvalgssortering public static int minimumPosition(int[] a, int from){ int minPos = from; for (int i=from+1; i

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

14 Køretid for udvalgssortering Husk public static void sort(int[] a){ for (int i=0; i { "@context": "http://schema.org", "@type": "ImageObject", "contentUrl": "http://images.slideplayer.dk/9/2652783/slides/slide_14.jpg", "name": "Køretid for udvalgssortering Husk public static void sort(int[] a){ for (int i=0; i

15 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 )

16 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

17 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] <- [] []

18 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

19 Fletning from mid mid+1 to Sorteret

20 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] { "@context": "http://schema.org", "@type": "ImageObject", "contentUrl": "http://images.slideplayer.dk/9/2652783/slides/slide_20.jpg", "name": "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]

21 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); }

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

23 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)

24 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)

25 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)

26 Eksempel Antal sammenligninger (<): Tabel med 1000 udvalgssortering: 499500 Flettesortering:8706 Tabel med 10000 udvalgssortering: 49995000 Flettesortering:120472

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


Download ppt "Begreber og Redskaber 7. Plan for idag Sorteringsalgoritmer Logaritmer,tabeller,køretid Simpelt iterativt: udvalgssortering Rekursivt: Flette sortering."

Lignende præsentationer


Annoncer fra Google