Iteracije in rekurzija

Slides:



Advertisements
Similar presentations
AP Computer Science Anthony Keen. Computer 101 What happens when you turn a computer on? –BIOS tries to start a system loader –A system loader tries to.
Advertisements

Introduction to Computer Science Robert Sedgewick and Kevin Wayne Recursive Factorial Demo pubic class Factorial {
ICE1341 Programming Languages Spring 2005 Lecture #13 Lecture #13 In-Young Ko iko.AT. icu.ac.kr iko.AT. icu.ac.kr Information and Communications University.
Recursive methods. Recursion A recursive method is a method that contains a call to itself Often used as an alternative to iteration when iteration is.
Fundamentals of Computer Science Lecture 14: Recursion Instructor: Evan Korth New York University.
Recursive Functions The Fibonacci function shown previously is recursive, that is, it calls itself Each call to a recursive method results in a separate.
Recursion. Recursive Definitions A recursive definition is one which uses the word being defined in the definition Not always useful:  for example, in.
Analysis of Recursive Algorithms What is a recurrence relation? Forming Recurrence Relations Solving Recurrence Relations Analysis Of Recursive Factorial.
1 Introduction to Recursion  Introduction to Recursion  Example 1: Factorial  Example 2: Reversing Strings  Example 3: Fibonacci  Infinite Recursion.
1 CSCD 300 Data Structures Recursion. 2 Proof by Induction Introduction only - topic will be covered in detail in CS 320 Prove: N   i = N ( N + 1.
Lecture 8 Analysis of Recursive Algorithms King Fahd University of Petroleum & Minerals College of Computer Science & Engineering Information & Computer.
Analysis of Recursive Algorithms What is a recurrence relation? Forming Recurrence Relations Solving Recurrence Relations Analysis Of Recursive Factorial.
Review of Recursion What is a Recursive Method? The need for Auxiliary (or Helper) Methods How Recursive Methods work Tracing of Recursive Methods.
Chapter 9 Recursion © 2006 Pearson Education Inc., Upper Saddle River, NJ. All rights reserved.
Miha Pihler MCSA, MCSE, MCT, CISSP, Microsoft MVP
General Features of Java Programming Language Variables and Data Types Operators Expressions Control Flow Statements.
Peter Andreae Computer Science Victoria University of Wellington Copyright: Peter Andreae, Victoria University of Wellington Recursion COMP 102 # T1.
Chapter 8 Recursion Modified.
An Introduction to Java – Part 1 Dylan Boltz. What is Java?  An object-oriented programming language  Developed and released by Sun in 1995  Designed.
Liang, Introduction to Java Programming, Eighth Edition, (c) 2011 Pearson Education, Inc. All rights reserved Chapter 20 Recursion.
Tihomir Ratkajec, MD, PhD.  Work has a very central role  spend a large part of ours life at work.  working situations are changed  the increasing.
1 CompSci 105 SS 2005 Principles of Computer Science Lecture 6: Recursion Lecturer: Santokh Singh Assignment 1 due tomorrow. Should have started working.
Uvod v C# Drugi del. Dedovanje Sintaksa Prirejanje in preverjanje tipov.
CS111 Computer Programming Department of Computer Science Wellesley College Classic Recursion Examples Plus Class Methods and Applications Tuesday, October.
1 EDUKACIJA BOLNIKOV pred uvedbo zdravila MAREVAN (tudi Sintrom) Alenka Mavri.
1 Recursion Recursion is a powerful programming technique that provides elegant solutions to certain problems. Chapter 11 focuses on explaining the underlying.
Recursion Chapter 17 Instructor: Scott Kristjanson CMPT 125/125 SFU Burnaby, Fall 2013.
Int fact (int n) { If (n == 0) return 1; else return n * fact (n – 1); } 5 void main () { Int Sum; : Sum = fact (5); : } Factorial Program Using Recursion.
1 Data Structures CSCI 132, Spring 2016 Notes 16 Tail Recursion.
SREČNO NOVO LETO 2009 Lara Koren, 2.c.
Števila in izrazi Naslov teme:Spremenljivka, operator, izraz in funkcija ure: 9 in 10 Učna metoda: demonstracija, samostojno delo Učni pripomočki: Računalnik,
Recursion You may have seen mathematical functions defined using recursion Factorial(x) = 1 if x
Review of Recursion What is a Recursive Method?
CS212: Data Structures and Algorithms
Unit 6 Analysis of Recursive Algorithms
Information and Computer Sciences University of Hawaii, Manoa
G. Pullaiah College of Engineering and Technology
Recursion -- Introduction
Introduction to Recursion
Recursion Chapter 12.
Principles of programming languages 4: Parameter passing, Scope rules
Java Software Structures: John Lewis & Joseph Chase
Uvod v Python
Delo s podatkovnimi bazami
Delo s podatkovnimi bazami
Grafični vmesnik - GUI Izdelava obrazca: lastnosti, odzivne metode
DELOVANJE POVEZAV V STANOVANJU
Recursive Definitions
Chapter 12 Recursion (methods calling themselves)
Fotografiranje hrane Predmet: Tipografija in reprodukcija.
Modulacija in demodulacija signalov (prirejeno po gradivu avtorja N
THE PAST SIMPLE TENSE navadni preteklik.
MS Excel, Open Office Calc, Gnumeric …
Објектно орјентисано програмирање
Algoritmi.
Calculate n! Multiply my number by the factorial of the rest of the numbers. if( num > 2 ) return num * factorialR2( num - 1 ); else return 2;
Ela Reven, Katarina urbančič
Ugani število Napišimo program, ki si “izmisli” naključno število, potem pa nas v zanki sprašuje, katero je izmišljeno število. Če število uganemo, nas.
CS201: Data Structures and Discrete Mathematics I
Stavek switch, zanka foreach
Chapter 8 Recursion.
Review of Recursion What is a Recursive Method?
Unit 3 Test: Friday.
Recursion Definition: A method that calls itself. Examples
Java Programming: Chapter 9: Recursion Second Edition
Review of Recursion What is a Recursive Method?
Recursion Method calling itself (circular definition)
More on iterations using
Review of Recursion What is a Recursive Method?
Presentation transcript:

Iteracije in rekurzija

Mehanizmi krmiljenja poteka Zaporedno izvajanje ( prednost izvedbe izrazov) Izbira (Selection) Iteracije Proceduralna abstrakcija Rekurzija Konkurenčnost Nedeterminizem Ta dva krmilna mehanizma dovolita računalniku ponavljanje izvajanja iste množice operacij Imperativni jeziki v glavnem temeljijo na iteracijah Funkcionalni jeziki v glavnem temeljijo na rekurziji.

Kaj je iteracija? var i, a := 0 // initialize a before iteration f Iteracija v računalništvu je ponavljanje procesa v računalniškem programu. Pri tem se neko stanje spreminja. Iteracija pomeni stil programiranja v imperativnih programskih jezikih. V nasprotju s tem ima rekurzija bolj deklarativni pristop. Primer iteracije, opisan v imperativni psevdokodi: var i, a := 0 // initialize a before iteration f For i from 1 to 3 { // loop three times a := a + i // increment a by the current value of i } print a // the number 6 is printed In computer science, imperative programming, as contrasted with declarative programming, is a programming paradigm that describes computation as statements that change a program state. In much the same way as the imperative mood in natural languages expresses commands to take action, imperative programs are a sequence of commands for the computer to perform. Procedural programming is a common method of executing imperative programming, and the terms are often used as synonyms.

Iteracije Iteracija ima običajno obliko zanke •Dve osnovni obliki: • Iteracija preko oštevilčenih množic. • Iteracijo krmilimo z logiko (dokler ni izpolnjen nek pogoj) Primeri:

Primer: Fibonaccijeva števila Fibonaccijeva števila tvorijo naslednje zaporedje 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, … Definiramo jih lahko tudi rekurzivno: fib(1) = 1 fib(2) = 1 fib(n) = fib(n – 1) + (fib(n – 2) za n > 2 To zaporedje je znano tudi kot problem množečih se zajčkov  n 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,...

Primer: plenilci in plen V danem področju imamo množico plenilcev (na primer lisic) in množico plenov (na primer zajčkov). Če ni plenilcev, se zajčki preveč razmnožijo. Če ni plena, plenilci stradajo in izumrejo. Ob dani začetni populaciji uporabimo diferenčne enačbe za simulacijo razvoja obeh populacij. Na primer : Ln+1 = Ln+ (c*Zn- d)* Ln; Zn+1= Zn+ (f- g* Ln)*Zn; L so lisice, Z so zajci. c, d,f, g so parametri . Nastavi začetne vrednosti populacij na Z0 in  L0

Populacija Lisic in zajcev

Lisice in zajci : koda zajcevPrej = 100; lisicPrej = 100; // zacetna populacija // c,d,f,g so parametri, ki jih moramo nastaviti for (time = tMin; time <= tMax; time += stepSize) { lisic = lisicPrej + (c*zajcevPrej - d)* lisicPrej; zajcev = zajcevPrej + (f- g* lisicPrej) * zajcevPrej; // zajcev oziroma lisic ne more biti manj kot nek minimum if (.lisic<10) lisic = 10; if (zajcev<10) zajcev=10; // priprava na nasledno iteracijo zajcevPrej = zajcev; lisicPrej = lisic; } Demo

Primeri rekurzije

Rekurzija Do rekurzije pride, če metoda kliče samo sebe, direktno ali indirektno preko verige klicev drugih metod. Metoda, ki kliče samo sebe, je rekurzivna metoda.

Primer: Izpis niza void print(String str, int index){ if (index < str.length()){ System.out.print(str.charAt(index)); print(str, index + 1); } print("Hello", 0); print("Hello", 1); print("Hello", 2); print("Hello", 3); print("Hello", 4); print("Hello", 5); Return Hello

Primer s potenco Imejmo asistenta, ki bo izračunal X y-2 Definicija potence je Xy = 1* X * X *…* X (y krat) Zamislimo si, da bi to morali računati ročno: X = 1* X * X *…* X (y krat) Kaj, če je y velik? Leni pristop: Imejmo asistenta, ki bo izračunal X y-1 in rezultat je = X * Xy-1 Imejmo asistenta, ki bo izračunal X y-2 Imejmo asistenta, ki bo izračunal X y-2 ….. do X0

Rekurzivno računanje potence Postopek naj bo naslednji: Za izračun potence x na y Če je y enak 0, ni kaj množiti, rezultat je 1. Če je y večji od 0, tedaj Prosimo asistenta, da izračuna potenco x na y-1. Rezultat je x krat rezultat asistenta.

Rekurzivna metoda private int potenca(int x, int y) { // y>=0, returns x**y int rezultatAsistenta; if (y==0) return 1; else { rezultatAsistenta = potenca(x,y-1); return x*rezultatAsistenta; } Korak prekinitve mora biti pred rekurzivnim klicem Preveri, če lahko postopek zaključimo brez rekurzije. Rekurzivni klic Argumenti v rekurzivnem klicu morajo določati nalogo, ki je lažja ali manjša od naloge, ki jo je zahteval klicatelj.

Sledenje klica : int z = factorial(4) Vrne 3*2 = 6 in konča factorial(3)= 3 * factorial(2) Vrne 2*1 =2 In konča factorial(4) končno lahko izračuna 4*6, vrne 24 in konča factorial(2)= 2 * factorial(1) Vrne 1*1 In konča factorial(1)= 1 * factorial(0) Vrne 1 In konča Ideas to present: Call stack – each call gets different set of parameters “wish-for” example. If I only had a function to compute 3!, I could invoke it, multiply the results by 4, and I would be done. The Wish-for function is really the recursive call, and we really don’t need to worry about how it works, just so long as the base case and the recurrence relationships are correct. Show that T(n) = K +T(n-1), so the time complexity of this function is also O(n), BUT the function calls have overhead, and so recursion can be time-consuming. Osnovni primer: factorial(0)= 1

Lastnosti rekurzivnih metod Vse rekurzivne metode imajo naslednje lastnosti: Enega ali več osnovnih primerov (najbolj enostavni primer), ki ga uporabimo za prekinitev rekurzije. Vsak rekurzivni klic mora originalni problem poenostaviti tako, da bo postopoma bližje osnovnemu primeru, dokler se s tem osnovnim primerom ne izenači.

Kako načrtujemo rekurzivne metode Korak 1. Bodimo leni. Uporabimo rešitev manjše ali lažje verzije problema in z njeno pomočjo rešimo naš problem. Ta korak vodi v rekurzivni klic. Korak 2. Vedeti, kdaj moramo nehati. Vedeti moramo, kdaj je problem tako enostaven, da ga lahko rešimo direktno. Ta korak vodi v kodo prekinitve.

Primer: innverzija niza Funkcija vrne niz, v katerem so znaki pomnjeni v obratnem vrstnem redu. If there are no more characters to examine Return the empty string Else Reverse the rest of the string after the current char Return the concatenation of this result and the char at the current position String reverse(String str, int index){ if (index == str.length()) return ""; else{ String rest = reverse(str, index + 1); return rest + str.charAt(index); }

Inverzija niza String reverse(String str, int index){ if (index == str.length()) return ""; else{ String rest = reverse(str, index + 1); return rest + str.charAt(index); } reverse("Hello", 0); reverse("Hello", 1); reverse("Hello", 2); reverse("Hello", 3); reverse("Hello", 4); reverse("Hello", 5); Return "" Return "o" Return "ol" Return "oll" Return "olle" Return "olleH" H e l l o

Inverzija niza String reverse(String str, int index){ if (index == str.length()) return ""; else{ String rest = reverse(str, index + 1); return rest + str.charAt(index); } reverse("Hello", 0); reverse("Hello", 1); reverse("Hello", 2); reverse("Hello", 3); reverse("Hello", 4); reverse("Hello", 5); Return "" Return "o" Return "ol" Return "oll" Return "olle" Return "olleH" H e l l o

Inverzija niza String reverse(String str, int index){ if (index == str.length()) return ""; else{ String rest = reverse(str, index + 1); return rest + str.charAt(index); } reverse("Hello", 0); reverse("Hello", 1); reverse("Hello", 2); reverse("Hello", 3); reverse("Hello", 4); reverse("Hello", 5); Return "" Return "o" Return "ol" Return "oll" Return "olle" Return "olleH" H e l l o

Inverzija niza String reverse(String str, int index){ if (index == str.length()) return ""; else{ String rest = reverse(str, index + 1); return rest + str.charAt(index); } reverse("Hello", 0); reverse("Hello", 1); reverse("Hello", 2); reverse("Hello", 3); reverse("Hello", 4); reverse("Hello", 5); Return "" Return "o" Return "ol" Return "oll" Return "olle" Return "olleH" H e l l o

Inverzija niza String reverse(String str, int index){ if (index == str.length()) return ""; else{ String rest = reverse(str, index + 1); return rest + str.charAt(index); } reverse("Hello", 0); reverse("Hello", 1); reverse("Hello", 2); reverse("Hello", 3); reverse("Hello", 4); reverse("Hello", 5); Return "" Return "o" Return "ol" Return "oll" Return "olle" Return "olleH" H e l l o

Inverzija niza String reverse(String str, int index){ if (index == str.length()) return ""; else{ String rest = reverse(str, index + 1); return rest + str.charAt(index); } reverse("Hello", 0); reverse("Hello", 1); reverse("Hello", 2); reverse("Hello", 3); reverse("Hello", 4); reverse("Hello", 5); Return "" Return "o" Return "ol" Return "oll" Return "olle" Return "olleH" H e l l o

Inverzija niza String reverse(String str, int index){ if (index == str.length()) return ""; else{ String rest = reverse(str, index + 1); return rest + str.charAt(index); } reverse("Hello", 0); reverse("Hello", 1); reverse("Hello", 2); reverse("Hello", 3); reverse("Hello", 4); reverse("Hello", 5); Return "" Return "o" Return "ol" Return "oll" Return "olle" Return "olleH" H e l l o

Inverzija niza String reverse(String str, int index){ if (index == str.length()) return ""; else{ String rest = reverse(str, index + 1); return rest + str.charAt(index); } reverse("Hello", 0); reverse("Hello", 1); reverse("Hello", 2); reverse("Hello", 3); reverse("Hello", 4); reverse("Hello", 5); Return "" Return "o" Return "ol" Return "oll" Return "olle" Return "olleH" H e l l o

Inverzija niza String reverse(String str, int index){ if (index == str.length()) return ""; else{ String rest = reverse(str, index + 1); return rest + str.charAt(index); } reverse("Hello", 0); reverse("Hello", 1); reverse("Hello", 2); reverse("Hello", 3); reverse("Hello", 4); reverse("Hello", 5); Return "" Return "o" Return "ol" Return "oll" Return "olle" Return "olleH" H e l l o

Inverzija niza String reverse(String str, int index){ if (index == str.length()) return ""; else{ String rest = reverse(str, index + 1); return rest + str.charAt(index); } reverse("Hello", 0); reverse("Hello", 1); reverse("Hello", 2); reverse("Hello", 3); reverse("Hello", 4); reverse("Hello", 5); Return "" Return "o" Return "ol" Return "oll" Return "olle" Return "olleH" H e l l o

Inverzija niza String reverse(String str, int index){ if (index == str.length()) return ""; else{ String rest = reverse(str, index + 1); return rest + str.charAt(index); } reverse("Hello", 0); reverse("Hello", 1); reverse("Hello", 2); reverse("Hello", 3); reverse("Hello", 4); reverse("Hello", 5); Return "" Return "o" Return "ol" Return "oll" Return "olle" Return "olleH" H e l l o

Inverzija niza String reverse(String str, int index){ if (index == str.length()) return ""; else{ String rest = reverse(str, index + 1); return rest + str.charAt(index); } reverse("Hello", 0); reverse("Hello", 1); reverse("Hello", 2); reverse("Hello", 3); reverse("Hello", 4); reverse("Hello", 5); Return "" Return "o" Return "ol" Return "oll" Return "olle" Return "olleH" H e l l o

Hanojski stolpiči Problem s Hanojskimi stolpiči je klasičen rekurzivni problem, ki temelji na preprosti igri. Imamo tri palice. Na eni je sklad ploščic z različnimi premeri. Cilj igre: Prestaviti vse ploščice na desno palico ob upoštevanju naslednjih pravil: Nobena ploščica ne sme biti nikoli na vrhu manjše ploščice. Naenkrat smemo premikati le po eno ploščico. Vsako ploščico moramo vedno odložiti na eno od palic, nikoli ob strani. Premaknemo lahko vedno le ploščico, ki je na vrhu nekega stolpiča. Zgodba pravi, da bi za fizičen premik 64 ploščic iz ene palice na drugo potrebovali toliko časa, da bi prej bil konec sveta. Demo

N ploščic s stolpa 1 na stolp 3 Začetno stanje: Stolp 1 Stolp 2 Stolp 3 Cilj: Stolp 1 Stolp 2 Stolp 3

Nekaj prvih korakov Premik n-1 ploščic Korak 1: Stolp 1 Stolp 2 Premik 1 ploščice Stolp 1 Stolp 2 Stolp 3 Korak 3: Premik n-1 ploščic Stolp 1 Stolp 2 Stolp 3

Koda v pascalu procedure Hanoi(n: integer; from, to, by: char); Begin if (n=1) then writeln('Move the plate from ', from, ' to ', to) else begin Hanoi(n-1, from, by, to); Hanoi(1, from, to, by); Hanoi(n-1, by, to, from); end; End;

Koda v javi (bolj popolna) public class TowersOfHanoi { public static void main(String[] args) { moveDisks(3, "Tower 1", "Tower 3", "Tower 2"); } public static void moveDisks(int n, String fromTower, String toTower, String auxTower) { if (n == 1) System.out.println("Move disk " + n + " from " + fromTower + " to " + toTower); else moveDisks(n-1, fromTower, auxTower, toTower); moveDisks(n-1, auxTower, toTower, fromTower); Move n-1 disks from from to temp, using to as a temporary. Move one disk from from to to. Move n-1 disks from temp to to, using from as a temporary.

Kakšen bi bil izpis Move disk 1 from Tower 1 to Tower 3

Primer s fraktali Demo

Preproga Sierpinski import java.applet.Applet; import java.awt.*; import java.awt.event.*; public class SierpinskiCarpet extends Applet { int level; public void init() { repaint(); } public synchronized void paint(Graphics g){ int i = getSize().width; int j = getSize().height; g.setColor(Color.white); g.fillRect(0, 0, i, j); level = 5; carpet(g, level, 0, 0, i, j);

Preproga Sierpinski (nadaljevanje) public void carpet(Graphics g, int i, int j, int k, int l, int i1){ if(i == 0) { g.setColor(Color.black); g.fillRect(j, k, l, i1); return; } else { int j1 = l / 3; int k1 = i1 / 3; carpet(g, i - 1, j, k, j1, k1); carpet(g, i - 1, j + j1, k, j1, k1); carpet(g, i - 1, j + 2 * j1, k, j1, k1); carpet(g, i - 1, j, k + k1, j1, k1); carpet(g, i - 1, j + 2 * j1, k + k1, j1, k1); carpet(g, i - 1, j, k + 2 * k1, j1, k1); carpet(g, i - 1, j + j1, k + 2 * k1, j1, k1); carpet(g, i - 1, j + 2 * j1, k + 2 * k1, j1, k1); return;

Primerjava iteracija : rekurzija (1) Uporabljamo strukture ponavljanja (for, while ali do…while) Ponavljanje skozi eksplicitno uporabo struktur ponavljanja Konča se, ko pogoj za ponavljanje zanke ne velja več (običajno) ponavljanja krmilimo s števcem Rekurzija Uporabljamo strukture izbiranja(if, if…else ali switch) Ponavljanje skozi ponovne klice metod oziroma funkcij Konča se, ko je izpolnjen osnovni primer Ponavljanje krmilimo z deljenjem problema na bolj enostavnega

Primerjava iteracija : rekurzija (1) Še o rekurziji Terja več režije kot iteracija Je pomnilniško bolj zahtevna od iteracije Rekurzivne probleme lahko rešujemo tudi z iteracijami Pogosto nam za rekurzijo zadošča le nekaj vrstic kode

Malo za sprostitev Podano je nekaj zaporedij. Ugotoviti moramo naslednje člene zašporedij. Vsak od navedenih problemov ima dva odgovora: eden je jasen, drugi pa bolj skrit. Problem A: 3, 1, 4, 1, 5, … Kateri je naslednji člen zaporedja? Problem B: 2, 3, 5, 8, … Kateri je naslednji člen zaporedja? Problem C: 2, 7, 1, 8, 2, 8, 1, 8, … Katera sta dva naslednja člena zaporedja? Odgovori A: preprosto = 1; skrito = 9; Odgovori B: preprosto = 12; skrito = 13; Odgovori C: preprosto =(2, 9); skrito = (2, 8);

Nedeterministični konstrukti Nedeterminstični konstrukti namenoma ne specificirajo izbire med alternativami. •Ta mehanizem je posebno uporaben v konkurenčnih programih