Lösungsvorschläge für das 7. Übungsblatt Letzte Änderung am 27. Juni 2001

Transkript

1 Grundlagen zu Datenstrukturen und Algorithen Schitt, Schöer SS U N S A R I V E R S A V I E I T A S N I S S Lösungsvorschläge für das 7. Übungsblatt Letzte Änderung a 27. Juni 2001 Aufgabe 1 h(x) (Ax Ax ) a) zeigen Sie: h(x) ɛ {0,..., 1 it (Ax) ɛ [ Ax, Ax [ (Ax Ax ) ɛ [0, 1[ ((Ax Ax )) ɛ [0, [ (Ax Ax ) {0,...,-1 b) zeigen Sie: Für x,y ɛ N it x y gilt Ax Ax Ay Ay Es gilt : Q + R\Q R\Q Q\0 R\Q R\Q Da nun (x y) 0 und A ɛ R\Q > (x y) A ɛ R\Q und it Ax, Ay ɛ Q > (x y)a Ax + Ay ɛ R\Q (x y)a Ax + Ay 0 Ax Ax Ay Ay 0 Ax Ax Ay Ay

2 Aufgabe 2 Das einfache Ausrechnen der jeweiligen Hash-Funktionen für die 19 Zahlen sollte relativ klar sein, uns interessiert, wie gut oder schlecht die Stundenten jeweils auf die 10 Stellen in unserer Hashtabelle verteilt werden. Da uns das ausrechnen zu langweilig ist, und uns Ipleentierungen interessieren sollten, basteln wir uns schnell eine siple Hash-Klasse in C++, der wir bei der Instanziierung einfach eine sinnvolle, selbstgebaute Hashfunktion übergeben koennen: Die Hashtabelle der Größe besteht dabei aus eine Array der Größe von Listen. Für die Hashfunktion übergeben wir einen Zeiger auf eine Funktion, die die zu hashenden Eleente auf eine Stelle in der Hashtabelle abbildet. Sofort wird klar, daß wir beliebige Eleente (auch Strings und Records und und und) hashen können, so lange wir uns selbst eine geeignete Hash-Funktion ausdenken :o) U das Entfernen von Eleenten aus de Hash küern wir uns nicht, hierzu üssen wir einfach die find-methode der Liste tabelle[h()] aufrufen. Hier aber acht das keinen Sinn, da an unseren Schlüsseln gar keine Daten hängen. /* hash.h */ #include <assert.h> #include "list.h" #include <stdio.h> #include <iostrea.h> teplate <class T> class hash { typedef list_node<t>* handle; //Dait wir die Listen proper handlen koennen list<t>* table; //Unsere Hashtabelle int (*h)(t); //Zeiger auf die Hashfunktion int size; //Groesse der Hashtabelle public: //Konstruktor erzeugt einen <T>hash(,f) it Groesse und hashfunktion f hash(int,int (*f)(t)){ table new list<t>[]; //Tabelle it leeren Listen initialisieren hf; //h-zeiger auf f biegen size; //Groesse festlegen void put(t ){ //fuegt Eleent in die Liste an der Stelle h() ein printf("%2d: %2d\n",,h()); table[h()].insert(table[h()].first(),); void dup(){ //Ausgabe des Hashes for (int i0;i<size;i++){ printf("%d:",i); for (handle j(table[i].last());j!(table[i].first()->prev);jj->prev) printf(" [%02d]",j->inf); printf("\n");

3 ; Zu Erledigen der Aufgabe können wir folgendes Hauptprogra benutzen. /* a2.cpp */ #include <stdlib.h> #include <stdio.h> #include <fstrea.h> #include <ath.h> #include "u_array.h" #include "hash.h" //Die Konstante A fuer Aufgabenteil c) float A (sqrt(5.0)-1)/2; //Hierit lesen wir das Feld aus einer Textdatei ein. void liesfeld(u_array<int> *feld){ fstrea input("studenten.txt",1); int i; int c0; while((input >> i)) (*feld).put(c++,i); //Die Drei Hashfunktionen int h1(int n){ int su0; while(n>0){ su+n % 10; n/10; if (su<10) return su; else return h1(su); int h2(int n){ return n%10; int h3(int n){ return (int)floor(10*(a*n-floor(a*n)));

4 //Hasht alle Werte aus *daten in den Uebergebenen Hash void perfor_hashing(hash<int> einhash,u_array<int> *daten){ for (int i0;i<(*daten).size();i++) einhash.put((*daten)[i]); void ain(){ u_array<int> studenten(0); //Drei Hashes der Breite 10 erzeugen hash<int> einhasha(10,h1); hash<int> einhashb(10,h2); hash<int> einhashc(10,h3); //Die Matrikelnuern einlesen liesfeld(&studenten); // for (int i0;i<100;i++) // studenten.put(i,(int)(((float)rando()/(float)rand_max)*100.0)); //Hashen perfor_hashing(einhasha,&studenten); cout << "\n"; perfor_hashing(einhashb,&studenten); cout << "\n"; perfor_hashing(einhashc,&studenten); //Ergebnisse Ausgeben printf("\nergebnis Teil a)\n"); einhasha.dup(); printf("\nergebnis Teil b)\n"); einhashb.dup(); printf("\nergebnis Teil c)\n\n"); einhashc.dup(); Zu Ergebnis: Ergebnis Teil a) 0: 1:->[37]->[91]->[82]->[19]->[01]->[01] 2:->[83] 3:->[12] 4: 5:->[95]->[41] 6:->[15] 7:->[52]->[52]->[88] 8:->[44]->[17]->[08]

5 9:->[63]->[54] Schlechte Verteilung, die 4 bleibt leer, die 1 hat alleine 6 Eleente. Ergebnis Teil b) 0: 1:->[91]->[41]->[01]->[01] 2:->[52]->[52]->[82]->[12] 3:->[83]->[63] 4:->[44]->[54] 5:->[95]->[15] 6: 7:->[37]->[17] 8:->[88]->[08] 9:->[19] Schon besser. auch wenn die 6 leer bleibt, ist sonst nur noch die 9 unterbesetzt Ergebnis Teil c) 0: 1:->[52]->[52]->[44] 2:->[83]->[91]->[15] 3:->[54]->[41]->[88] 4:->[12] 5:->[17] 6:->[82]->[01]->[01] 7:->[95]->[19] 8:->[37] 9:->[63]->[08] Beste Verteilung. Außer der 0 (die bei allen leer bleibt!) sind alle Stellen besetzt, aber nirgendwo haben wir ehr als drei Eleente auf einal. Da wir nun schon die schöne Ipleentierung schon haben, können wir unsere 19 Studenten durch folgende kleine Änderung //Die Matrikelnuern einlesen //liesfeld(&studenten); srando(tie(null)); for (int i0;i<400;i++) studenten.put(i,(int)(((float)rando()/(float)rand_max)*100.0)); durch 400 zufällige Studenten ersetzen und uns die Ergebnisse (hier, weils keinen ehr interessiert, was für Schlüssel es waren, durch Sternchen vereinfacht) anschauen: Ergebnis Teil a)

6 0:*** 1:********************************************* 2:********************************************* 3:****************************************** 4:************************************************************* 5:************************************** 6:************************************************ 7:*************************************** 8:************************************** 9:***************************************** Ergebnis Teil b) 0:*********************************** 1:********************************************** 2:**************************************** 3:********************************* 4:**************************************************** 5:****************************************** 6:*********************************************** 7:************************************** 8:******************************* 9:************************************ Ergebnis Teil c) 0:************************************ 1:************************************* 2:****************************************** 3:******************************************* 4:*********************************** 5:*************************************** 6:************************************ 7:********************************************** 8:******************************************* 9:******************************************* Während b) und c) recht ähnlich gute Ergebnisse liefern, scheitert Funktion a) daran, daß die Quersue nur genau dann Null ist, wenn die zugrundeliegende Zahl Null ist. Also Wahrscheinlichkeit, daß ein Eleent in die Nullte Liste kot. Soit verlieren wir praktisch ein ganzes Feld, und das ist keine gute Idee. Aufgabe 3 a) Es uß untersucht werden, ob h injektiv ist, d.h. ob x, y S : h(x) h(y) gilt. 1. Erstelle Array Meory der Länge (O(1)), und initialisiere es it 0 (O()) 2. Berechne (O(1)) für jedes x S h(x) (O(n)), und addiere i Array Meory an der Stelle h(x) 1 (O(1))

7 3. Laufe durch Array Meory (O()), und gebe false zurück, falls einer der Einträge / {0, 1 ist, sonst true Laufzeit: 1. kostet Zeit O(1) + O() O() 2. kostet Zeit O(n) (O(1) + O(1)) O(n) 3. kostet Zeit O() O( + n) b) Hier fehlt uns die Zeit zu Initialisieren. 1. Erstelle Array Meory der Länge (O(1)), und initialisiere es nicht! 2. Berechne (O(1)) für jedes x S h(x) (O(n)), weise Meory[h(x)] x zu 3. Berechne für jedes x S h(x) (bzw. in 2. erken), und teste Meory[h(x)] x Beende it false ab, falls ungleich, oder gebe true zurück. Laufzeit: 1. kostet Zeit O(1) (!!!) 2. kostet Zeit O(n) (O(1) + O(1)) O(n) 3. kostet Zeit O(n) (O(1) + O(1)) O(n) Korrektheit: Nach 1. steht in Meory Speicherüll. 2. weist jede Meory[h(x)] x zu. Gehen wir jetzt davon aus, daß h nicht injektiv ist, d.h. y, z S : y z, h(y) h(z). Bei Durchlauf durch S in 2. gibt es eine bestite Reihenfolge. Sei o.b.d.a. y vor z: d.h. a Ende von 2. steht an der Stelle Meory[h(y)] z und nicht ehr y, weil y von z überschrieben wird. Bei Durchlauf in 3. ist die Bedingung Meory[h(x)] x für x y also nicht erfüllt und es kot zu Abbruch it false. Aufgabe 4 1. Zuerst erinnern wir uns an die Definition des Erwartungswertes. Sei X eine Zufallsvaribale, dann gilt für den Erwartungswert: E(X) x P (X x) t x X(Ω) x X(Ω) x t x X(Ω) x t x P (X x), da x X(Ω) : x 0 P (X x) t P (X t) P (X t) E(X), da t > 0 t, dap (X x) 0 x t 2. Behauptung:, k N, 0 k 1 : 1 ik ( ) ( ) i k k + 1

8 Beweis: durch vollständige Induktion über Sei 1 : 1 ( i ) ( ik k 0 ) ( ( 1) ) k+1 Sei > 1 und die Behauptung für schon bewiesen, zeige für + 1: (gilt nur für 1 k 1) Aufgabe 5 Fall k : ik ( ) i k i 1 ( ) ( ) i + k k ik ( ) ( ) + Induktionsannahe k + 1 k! (k + 1)!( k 1)! +! k!( k)!!( k + k + 1) (k + 1)!( k)! ( + 1)! (k + 1)!( + 1 (k + 1))! ( ) + 1 k + 1 ( i ) ( ) 1 ( a) Das sind N(N 1) viele Funktionen. Der Faktor N 1 ergibt sich aus der freien Wahl von < N, der Faktor N aus der Wahl von a, wobei für a > N gilt, daß sich die Funktion wie eine der Funktionen it a < N verhält: a > N b N, c N it a b + c N, und dait fällt c N wegen c N od N 0 nicht ins Gewicht. b) H x H y ((ax + b) od N) ((ay + b) od N) (ax + b ay b) od N (a (x y)) od N { (N 1),..., N 1 untere Schranke (N 1), obere Schranke N 1. c) Dait H x H y i kann i nur folgende Werte annehen: 0 < i N 1. Dabei ist i 0 unöglich, da x y und a 0 nach Vorraussetzung. Es ergeben sich soit 2 N 1 ögliche Werte für i. d) Es ist h a,b (x) h a,b (y) ((ax + b) od N) od ((ay + b) od N) od Dabei ist die Zahl ((ax + b) od N (ay + b) od N). (ax + b) od N (ay + b) od N (ax) od N (ay) od N )

9 aus der Menge { (N 1),..., N 1. Diese Zahl wird durch genau dann geteilt, wenn es ein i it 0 < i N 1 gibt it ((ax) od N (ay) od N) i a(x y) i od N. Dabei kann i nicht gleich 0 sein, da sonst x y oder a 0 folgen würde. Für den Wert von i erhalten wir also 2 N 1 Möglichkeiten. Jeder Wert von i führt zu eine anderen Wert von a ittels a i/(x y) od N. Für a erhalten wir also 2 N 1 Möglichkeiten. Für das b gibt es N Möglichkeiten, also haben wir N(N 1) 2 Möglichkeiten für Paare (a, b) it h a,b (x) h a,b (y). e) Dait ist N(N 1) {(a, b) U\{0 U h a,b (x) h a,b (y) 2 und diese Klasse ist 2-universell.