TILLÄMPAD DATALOGI
(TILDA)
Övning 2
www.nada.kth.se/~mhj/tilda
Rekursion
Binärträd
Tidskomplexitet
Sökning
Hemtal
Rekursion
Ex 1: Fakultet
t.ex. fakultet(5) = 5 * 4 * 3 * 2 * 1 = 120
Basfall:
fakultet(1) = 1
Rekursion (annars):
fakultet(5) = 5 * fakultet(4)
fakultet(5) = 5 * fakultet(4)
fakultet(4) = 4 * fakultet(3)
fakultet(3) = 3 * fakultet(2)
fakultet(2) = 2 * fakultet(1)
fakultet(1) = 1
1
2
6
24
120
Ex 1: Fakultet
fakultet(n) = n * n-1 * … * 2 * 1
Basfall:
fakultet(1) = 1
Rekursion (annars):
fakultet(n) = n * fakultet(n-1)
class RekursionFakultet {
public static void main(String [] args) {
System.out.println(fakultetA(3));
}
public static int fakultetA(int tal) {
if (tal == 1)
return 1;
else
return tal * fakultetB(tal-1);
}
public static int fakultetB(int tal) {
if (tal == 1)
return 1;
else
return tal * fakultetC(tal-1);
}
public static int fakultetC(int tal) {
if (tal == 1)
return 1;
else
return tal * fakultetD(tal-1);
}
}
6
1
2
6
tal
3
tal
2
tal
1
class RekursionFakultet {
public static void main(String [] args) {
System.out.println(fakultet(2));
System.out.println(fakultet(4));
}
public static int fakultet(int tal) {
if (tal == 1) {
return 1;
}
else {
int f;
f = tal * fakultet(tal-1);
return f;
}
}
}
2
2
tal
0
f
1
tal
2
0
f
6
2
tal
0
f
2
1
tal
3
24
4
24
1
2
6
class RekursionFakultet {
public static void main(String [] args) {
System.out.println(fakultet(2));
System.out.println(fakultet(4));
}
public static int fakultet(int tal) {
if (tal == 1)
return 1;
else
return tal * fakultet(tal-1);
}
}
Ex2 : Palindrom
t.ex. rar, alla, r, ””, naturrutan
Basfall:
1. om första och sista tecknet i ordet är olika är ordet
inte ett palindrom
2. om ordet har 0-1 tecken är det ett palindrom
Rekursion (annars):
ordet är ett palindrom om texten mellan första och sista
bokstaven i ordet är ett palindrom
Ex. naturrutan är ett palindrom om och endast om
aturruta är ett palindrom
class RekursionPalindrom {
public static void main(String [] args) {
String n1 = ”david”;
String n2 = ”anna”;
System.out.println(ärPalindrom(n1));
System.out.println(ärPalindrom(n2));
}
public static boolean ärPalindrom(String s) {
int len = s.length();
// basfall 1
if (len <= 1) {
return true;
}
// basfall 2
else if (s.charAt(0) != s.charAt(len-1)) {
return false;
}
// rekursion
else {
String s2 = s.substring(1, len-1);
return ärPalindrom(s2);
}
}}
false
true
s
”david”
len
5
s2
”avi”
s
len
3
s2
””
s
len
0
2
4
”nn”
”anna”
Ex3 : Längden på en stack
Basfall:
En tom stack har längd 0
Rekursion (annars):
En stack har längd
1 + stackens längd utan det översta elementet
class RekursionStack {
public static void main(String [] args) {
Stack stack = new Stack();
stack.push(3);
stack.push(5);
stack.push(4);
System.out.println(stack.lenght());
}
}
class Node {
public int nr;
public Node next;
public Node(int nr) {
this.nr = nr;
next = null;
}
}
class Stack {
private Node top;
public Stack() {
top = null;
}
public int lenght() {
return lenght(top);
}
private int lenght(Node n) {
if (n == null) // basfall
return 0;
else // rekursion
return 1 + lenght(n.next);
}
public void push(int nr) {
Node node = new Node(nr);
node.next = top;
top = node;
}
public int pop() {
int nr = top.nr;
top = top.next;
return nr;
}
}
stack
null
top
3
nr
null
next
null
5
nr
next
4
nr
null
next
3
n
null
n
n
n
Binärträd
Binärträd
insert(5)
insert(2)
insert(6)
insert(8)
insert(9)
insert(4)
insert(7)
5
2
6
8
4
7
9
5
2
6
8
Binärträd
insert(5)
insert(2)
insert(6)
insert(8)
insert(9)
insert(4)
insert(7)
root
new BinTree()
2
5
6
8
9
7
4
public class Node {
private int nr;
private Node left;
private Node right;
public Node(int nr) {
this.nr = nr;
left = null;
right = null;
}
}
public class BinTree {
private Node root;
public BinTree() {
root = null;
}
public int sum() {
return sum(root);
}
public int sum(Node n) {
if (n == null)
return 0;
else
return n.nr + sum(n.left) +
sum(n.right);
}
}
tree
root
null
l
null
null
nr
7
r
null
l
null
nr
9
r
null
l
null
nr
4
r
null
l
null
nr
3
r
null
l
null
nr
6
r
public class BinTreeSum {
public static void main(…) {
BinTree tree=new BinTree();
tree.insert(7);
tree.insert(4);
tree.insert(9);
tree.insert(6);
tree.insert(3);
tree.sum();
} }
3
6
13
9
29
29
public class BinTree {
private Node root;
public BinTree() {
root = null;
}
public int noOfNodes() {
return noOfNodes(root);
}
public int noOfNodes(Node n) {
if (n == null)
return 0;
else
return 1 + noOfNodes(n.left) +
noOfNodes(n.right);
}
}
tree
root
null
l
null
null
nr
7
r
null
l
null
nr
9
r
null
l
null
nr
4
r
null
l
null
nr
3
r
null
l
null
nr
6
r
public class BinTreeNrOfNodes {
public static void main(…) {
BinTree tree=new BinTree();
tree.insert(7);
tree.insert(4);
tree.insert(9);
tree.insert(6);
tree.insert(3);
tree.noOfNodes();
} }
1
1
3
1
5
5
public class BinTree {
private Node root;
public BinTree() {
root = null;
}
public int depth() {
return depth(root);
}
public int depth(Node n) {
if (n == null)
return 0;
else
return 1 +
Math.max(depth(n.left),
depth(n.right));
}
}
tree
root
null
l
null
null
nr
7
r
null
l
null
nr
9
r
null
l
null
nr
4
r
null
l
null
nr
3
r
null
l
null
nr
6
r
public class BinTreeDepth {
public static void main(…) {
BinTree tree=new BinTree();
tree.insert(7);
tree.insert(4);
tree.insert(9);
tree.insert(6);
tree.insert(3);
tree.depth();
} }
1
1
2
1
3
3
Tidskomplexitet
Tidskomplexitet
for (int i = 0; i < n; i++) {
a = a + 2;
a--;
}
k
n
k * n = O(n)
Tidskomplexitet
for (int i = 0; i < n; i++) {
a = a + 2;
a--;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
a = a + 2;
a--
}
}
k
n
k
n
n
k * n + k * n * n <= k * n2 + k * n2 = 2 * k * n2 = O(n2)
Tidskomplexitet
for (int i = 0; i < n; i++) {
a = a + 2;
a--;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
a = a + 2;
a--
}
}
O(n)
O(n2)
O(n) + O(n2) = O(n2)
Tidskomplexitet
for (int i = 0; i < n; i++) {
a = a + 2;
a--;
}
for (int i = 0; i < n; i++) {
sum++;
}
O(n)
O(n)
O(n) + O(n) = O(n)
Tidskomplexitet
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= i; j++) {
sum++;
}
}
k + 2k + … + nk = k * (1+2 + … + n) = k * (n2+n)/2 = O(n2)
k
Tidskomplexitet
Algoritm
n = 100
n = 500
n = 500
k1 * n
0,5 ms
2,5 ms
5x längre
k2 * n2
0,5 ms
12,5 ms
25x längre
k3 * n3
0,5 ms
62,5 ms
125x längre
k4 * 2n
0,5 ms
1,3*10120 ms
= 4,1*10109 år
2,6 * 10120x längre
jämför
tid
tid
Sökning
Ex) Gotland Runt har en databas med information om 512 båtar.Lista fördelar och nackdelar med linjärsökning resp.binärsökning i datat.
Linjärsökning:
Fördelar: Kan använda länkad lista eller vektor för attlagra informationen
Nackdelar:Lång tid att söka O(n), medel 250 jämförelser
Binärsökning:
Fördelar:Snabbt att söka O(log n), medel ~9 jämförelser
Nackdelar:Kräver en array.
Kräver att arrayen är sorterad.
Anne
Beatrice
Daniella
Victoria
Ylva
Zandra
...
0
1
2
509
510
511
512, 256, 128,64, 32, 16, 8,4, 2, 1
Hemtal