Opis zagadnień 1 -3

Opis zagadnieo 1 -3
Iteracja, rekurencja i ich realizacja
Iteracja
Iteracja to czynnośd powtarzania (najczęściej
wielokrotnego) tej samej instrukcji (albo wielu
instrukcji) w pętli. Mianem iteracji określa się
także operacje wykonywane wewnątrz takiej
pętli
Przykład iteracji
Czynnośd iteracji przedstawia pętla, zapisana w poniższym
pseudokodzie:
java:
i=0
dopóki i< 10
inkrementuj i
przeskocz do góry
int i=0;
while(i<10) {
i++;
}
W pierwszej iteracji otrzymamy wartośd i=1, w następnej i=2,
potem i=3 i tak dalej, a iteracją jest powtarzana tu czynnośd,
czyli zwiększanie zmiennej i o jeden.
Rekurencja
Rekurencja (rekursja) jest podstawową techniką
wykorzystywaną w językach programowania, dzięki
której np. definicja lub funkcja może odwoład się do
samej siebie.
Programy rekurencyjne są często mniejsze i
łatwiejsze do zrozumienia od ich iteracyjnych
odpowiedników
Nie wszystkie języki programowania mają
możliwośd używania rekurencji. Przykładem jest np.
COBOL
Silnia
public int silnia(int x) {
if(x==0) {
return 1;
}
return x*silnia(x-1);
}
Przykład użycia silnia(3)
Silnia(3)
3*Silnia(2)
2*silnia(1)
1*silnia(0)
1
1*1
2*1
3*2
Ciąg Fibonacciego
F0 = 1 ; F1 = 1 ; Fn = Fn-1 + Fn-2
public int fib(int x) {
if(x<2) {
return 1;
}
return fib(x-1)+fib(x-2);
}
Ciąg Fibonacciego - iteracja
package przyklad_1_fib;
public class Przyklad_1_fib {
public static void main(String[] args) {
int liczba = 80;
System.out.println( "Wynik dla liczby " + liczba + ": " + fib_i(liczba) );
}
public static long fib_i(int n) {
long a = 0, b = 1;
for(int i=0;i<n;i++)
{
b += a; //pod zmienną b przypisujemy wyraz następny czyli a+b
a = b-a; //pod zmienną a przypisujemy wartośd zmiennej b
}
return b;
}
}
Ciąg Fibonacciego - rekurencja
package przyklad_1_fib;
public class Przyklad_1_fib {
public static void main(String[] args) {
int liczba = 80;
for(int i = 0; i <= 80 ; i++) {
System.out.println( "Wynik dla liczby " + i + ": " + fib_r(i) );
}
}
public static long fib_r(int n) {
if(n < 2) return 1;
return fib_r(n-1) + fib_r(n-2);
}
}
Problemy rekurencji
Najwięcej problemów związanych z rekurencją
wiąże się z ograniczeniami stosu wywołao, a
właściwie jego pojemności. Na stosie są
odkładane kolejne wywołania danej metody i
dopiero gdy dojdziemy do ostatniego elementu
dane te są zbierane – bardzo łatwo więc o
sytuację, gdy po prostu stos przepełnimy.
Instrukcja warunkowa switch - case
Instrukcja warunkowa wielokrotnego wyboru na
podstawie tylko jednej zmiennej.
Switch( zmienna ) {
case 0: zmienna++; break;
default: zmienna+=2; break;
}
Instrukcja warunkowa if
if [else if] [else]
Pozwala zmienid przebieg wykonywania kodu w
zależności od wartości logicznej wyrażenia:
if (warunek) {
//instrukcje
} else if (warunek) {
//instrukcje
} else {
//instrukcje
}
Operator trójargumentowy
Konstrukcja:
wyrażenie ? Prawda : fałsz ;
Przykład:
Person p = new Person();
int tmp = p.isEmployed() ? p.getSalary() : 0;
Pętla for
• Konstrukcja:
for(i; warunek koncowy; operacje na i)
Gdzie i to licznik petli, a operacje na i to zazwyczaj
zwiększanie/zmniejszanie o 1.
• Dzięki swojej konstrukcji pozwala np na łatwe
przechodzenie po tablicach/listach
• Pozwala na łatwe przejście po zakresie liczb np.:
10 – 50 lub 50 – 10
• Warunek jest sprawdzany na początku pętli
• Pętla wykonuje się dopóki zachodzi dany warunek
For - przykład
int suma = 0;
for(int i=0;i<10;i++) {
suma += i;
}
For - przykład
package przyklad_1_fib;
public class Przyklad_1_fib {
public static void main(String[] args) {
int suma = 0;
for(int i=0; i<20 && i%5==0 ;i+=2) {
if( i % 5 == 0)
suma += i;
}
System.out.println(suma);
}
}
Pętla foreach
• Odmiana pętli for, wykonująca się dla każdego
elementu z pewnego zbioru/kolekji.
• Konstrukcja:
for(element : zbior)
• W każdej iteracji ‚element’ będzie kolejnym
elementem zbioru.
Foreach – przykład
List<Person> persons = new ArrayList<Person>();
//wypełnianie tablicy persons
Foreach(Person p : persons) {
//instrukcje na p
}
Pętla while
• Konstrukcja:
while(wyrazenie) {
//instrukcje
}
• Wykonuje się dopóki dane wyrażenie zwraca
true
• Warunek jest sprawdzany na początku pętli
Pętla while - przykład
Int k = 100;
while(k <= 1000000000) {
//instrukcje
k *= 10;
}
Pętla do-while
• Konstrukcja:
do { //instrukcje }
while(wyrazenie);
• Wyrażenie sprawdzane jest po każdej iteracji
• Zatem pętla wykona się przynajmniej raz
Podprogram
• Podprogram (inaczej funkcja lub procedura) –
termin związany z programowaniem
proceduralnym. Podprogram to wydzielona
częśd programu wykonująca jakieś operacje.
Podprogramy stosuje się, aby uprościd
program główny i zwiększyd czytelnośd kodu
Sposoby przekazywania parametrów
•
•
•
•
Przekazywanie przez wartośd.
Przekazywanie przez wynik.
Przekazywanie przez referencję.
Przekazywanie przez nazwę.
Przykład przekazywania przez wartośd
#include <iostream>
using namespace std;
void zmien_x(int x) {
x *=2;
cout << "X z procedury " << x << endl;
}
int main() {
int x = 4;
zmien_x(x);
cout << "X z main " << x << endl;
return 0;
}
Przykład przekazywania przez
referencję
#include <iostream>
using namespace std;
void zmien_x_2(int & x) {
x *= 2;
cout << "X z procedury " << x << endl;
}
int main() {
int x = 4;
zmien_x_2(x);
cout << "X z main " << x << endl;
return 0;
}