Algoritmer og datastrukturer

1. Algoritmer og datastrukturer Af: Per Printz Madsen Hjemmeside: http://www.control.auc.dk/~ppm/E4kurser/Note/ Indhold: • Grundprincipper og analyse af algoritmer. MM1 • Lister, stakke og køer. MM2  • Træer, og Hash-tabeller. MM3 • Eksempler på algoritmer. fx. • Sortering. MM4 • Søgning. MM5 Per P. Madsen- Proces

2. Datastruktur Datastruktur: En organisering af data, ofte anvendt af en algoritme. Fx: Lister, linkede-lister, stakke, køer, træer, hash-tabeller og grafer. Ved valg af datastruktur bør overvejes: • Effektivitet • Abstraktion • Genbrug Per P. Madsen- Proces

3. Abstrakt datatype En datastruktur med tilhørende operationer. Ideen er, at der fokuseres på anvendelsen af data og ikke på implementationen. Definition: A set of data values and associated operations that are precisely specified independent of any particular implementation. • Datastruktur fx. en liste. • Metoder fx. insert, delete, find osv. Per P. Madsen- Proces

4. Simpel list eksempel: list.c #include ”list.h” typedef struct DataElm_ { void *Data; } DataElm; static DataElm list[ListSize]; void init_list() { int index; for(index=0; index<ListSize; index++) list[index].Data= (void *)0; } int insert_data(void *data) { int index=0; while ((list[index].Data != 0) && (index < ListSize)) ++index; list[index].Data= data; return (index < ListSize)? index : ListFull; } Per P. Madsen- Proces

5. Interface: list.h #define ListFull -1 #define ListSize 10 void init_list(); int insert_data(void *data); void delete_data(int index); int find_data(void *data); Per P. Madsen- Proces

6. Algoritmer Algoritme: En veldefineret opskrift på at løse en opgave. Per P. Madsen- Proces

7. Algoritmer Algoritme: En procedure for løsning af en opgave. Fx: Søgning, sortering, komprimering, kryptering, beregning, osv. Ved opbygning af algoritmer bør overvejes: • Effektivitet • Hvis generel anvendelse så også abstraktion. Per P. Madsen- Proces

8. Grundlæggende algoritmer. En god algoritme anvender de rigtige metoder til at løse en opgave. Med ”rigtig metode” menes der her ”mest effektive metode” Grundlæggende metoder: • Divide-and-conquer algoritmer. • Baseret på deling i håndterbare og uafhængige størrelser, der hver især kan håndteres og sammensættes igen. Ofte rekursiv. • Dynamisk-programmering algoritmer. • Problemløsningen deles i afhængige delproblemer. • Greedy algoritmer. • Lokaloptimering. • Approximations algoritmer. • En iterativ søgning efter en ”god nok” løsning. • Randomized eller Probabilistic algoritmer. • Baseret på statistiske egenskaber ved tilfældige tal. Per P. Madsen- Proces

9. Algoritmiske grundprincipper • Iteration • Rekursion • Induktion Per P. Madsen- Proces

10. x xny Iteration En gentagen udførelse af samme trin. Fx: Find minimum af en funktion. • Start et sted: x • Gentag mange gange { • Find gradienten: g • x= x – A*g : hvor A er et lille tal. • } Per P. Madsen- Proces

11. 1 for n= 0, 1 n!= F(n)= { n*F(n-1) for n > 1 Rekursion: Recursion • F(n) { • res=1; • Gentag sålænge n >1 { • res= res*n; • n= n - 1; • } • return res; • } Fakultet: n!= n*(n-1)*(n-2)*..... * 1 Iterativ: • F(n) { • Hvis n >1 • return n*F(n-1); • else return 1 • } Per P. Madsen- Proces

12. F(4) Per P. Madsen- Proces

13. Recursion • Regel 1 Enhver rekursiv procedure skal ha’ en slutbetingelse hvor der ikke foretages rekursion. • Regel 2 Rekursive procedurer skal bevæge sig hen mod slutbetingelsen. Per P. Madsen- Proces

14. ’_’PC 0 til buffer d til buffer ’d’PC ’r’PC r til buffer o til buffer ’o’PC Recursion Tekst: ”ord_tal ....” char buf[80]; int i; putbuf(char ch) { buf[i++]=ch; } void nextWord() { char ch= getCh(); if (('a‘ < ch)&&(ch < 'z')) { putbuf(ch); nextWord(); } else putbuf(0); } Buffer Stak Per P. Madsen- Proces

15. Recursion ’_’PC char buf[80]; int i; putbuf(char ch) { buf[i++]=ch; } void nextWord() { char ch= getCh(); if (('a‘ < ch)&&(ch < 'z')) { putbuf(ch); nextWord(); } else putbuf(0); } ’d’PC ”ord\0” ’r’PC ’o’PC Stak Per P. Madsen- Proces

16. Recursion char buf[80]; int i; putbuf(char ch) { buf[i++]=ch; } void nextWord() { char ch= getCh(); if (('a‘ < ch)&&(ch < 'z')) { putbuf(ch); nextWord(); } else putbuf(0); } ’d’PC ”ord\0” ’r’PC ’o’PC Stak Per P. Madsen- Proces

17. Recursion char buf[80]; int i; putbuf(char ch) { buf[i++]=ch; } void nextWord() { char ch= getCh(); if (('a‘ < ch)&&(ch < 'z')) { putbuf(ch); nextWord(); } else putbuf(0); } ”ord\0” ’r’PC ’o’PC Stak Per P. Madsen- Proces

18. Recursion char buf[80]; int i; putbuf(char ch) { buf[i++]=ch; } void nextWord() { char ch= getCh(); if (('a‘ < ch)&&(ch < 'z')) { putbuf(ch); nextWord(); } else putbuf(0); } ”ord\0” ’o’PC Stak Per P. Madsen- Proces

19. Recursion char buf[80]; int i; putbuf(char ch) { buf[i++]=ch; } void nextWord() { char ch= getCh(); if (('a‘ < ch)&&(ch < 'z')) { putbuf(ch); nextWord(); } else putbuf(0); } ”ord\0” Stak Per P. Madsen- Proces

20. Rekursion double power(double number, int pow){ if (pow == 0) return 1.0; else if (pow > 0) return number * power(number, pow - 1); else return 1.0 / power(number, -pow); } Per P. Madsen- Proces

21. Induktion Ofte brugt til at give formelt bevis for en algoritmes korrekthed. Princip: • P(0) er korrekt. • For n >= 0: Hvis P(n) er korrekt, så er P(n+1) også korrekt. Per P. Madsen- Proces

22. 1 for n= 0, 1 n!= F(n)= { n*F(n-1) for n > 1 Recursion • F(n) { • Hvis n >1 • return n*F(n-1); • else return 1 • } Per P. Madsen- Proces

23. Analyse af algoritmer • Dvs. analyse af hvordan en algoritme performer mht brug af resurser almenligvis CPU-tid. • Complexitet: Udviklingstakten for tidsforbrug mht. datamængden. • Emne: • O-notation. • En formel metode til at beskrive en algoritmes complexitet. Per P. Madsen- Proces

24. O-Notation • Problemet: • Hvor hurtigt vokser afviklingstiden for en given algoritme, når den mængde data, der skal proceseres, vokser. • Givet at afviklingstiden f(n), hvor n er datamængden. • hvis f(n)= a*n + b*n + ... + c og n >> 1 • Så er f(n)~ n den interessante del. p p-1 p Per P. Madsen- Proces

25. O-Notation • Formelt: • O(T(n))={f(n): Der eksisterer en positiv konstant C og n0 • således at: 0<= f(n) <= C*T(n) for alle n >= n0}; C*T(n) f(n) n n0 Per P. Madsen- Proces

26. O-Notation • Regneregler: • Konstantled: • O(c) = O(1) • Multiplicer med en konstant: • O(cT) = cO(T) = O(T) • Sum: • O(T1) + O(T2) = O(T1 + T2) = max(O(T1), O(T2)) • Multiplikation: • O(T1)O(T2) = O(T1*T2) Per P. Madsen- Proces

27. O-Notation c1 c2 f(n) = c1 + c2 + n(c3 + c4) +c5 Dvs: T(n)= n; Dvs. komplexiteten: O(n) c3 n gange c4 c5 Per P. Madsen- Proces

28. O-Notation Eksempler på alm. forekommende komplexiteter: O(1): Hent et element, man ved hvor er. O(log2(n)): Find et element i et binærtræ. O(n): Find et element i en liste. O(n2): Gennemsøg et sæt af data for hvert element i et sæt. O(2n): Generer alle subsæt af et givet datasæt. O(n!): Generer alle mulige permutationer af et sæt. Per P. Madsen- Proces

29. O-Notation void bubbleSort() { int out, in; // c1 for(out=nElems-1; out>1; out--) // outer loop for(in=0; in<out; in++) // inner loop if( a[in] > a[in+1] ) // out of order? swap(in, in+1); // swap them. c2 } // c3 Løkke inden i løkke: f(n) = c1 + ((n-1)(n-1)/2)c2 +c3 = c1+c3+ ((n2- 2n+1)/2)c2 => O(n2): Per P. Madsen- Proces