Listen:
=====
einfache Listen
- iterativ
- rekursiv
Sonderlisten
- Dummy am Kopf
- vor- / rückwärts verkettete Listen
- Ring
- mehrfach verkettete Listen
Anwendungen
- Stack
- Queue

============================
CODE
============================

[Kopf]-->[C]-->[M]-->[T]-->(NIL)

*Kopf entfernen*
if not self.empty then
begin
blah := kopf; //Hilfszeiger
kopf := kopf^.next;
dispose(blah);
end;

SOM:

res 6
push_adr 1
pop 0
loop: get
pop_i 0 //pop_iz 0
push 0
push_num 1
add
pop 0
push 0
push_adr 6
sub
jump_ne loop
stop

unit adjazenz;

interface
uses liste; //unit uListe implementieren

type
tOrte = (Augsburg, Duesseldorf, Koeln, Langenfeld, Monheim);
tAdjMatrix = array [tOrte, tOrte] of integer;
tAdjListenfeld = array [tOrte] of Liste; //ort --> orte

tNachbarn = class
matrix : tAdjMatrix;
listenfeld : tAdjListenfeld;
constructor init;
procedure matrix_in_liste;
procedure gib_verbindungen_aus;
end;

const
map : array [tOrte] of string = ('A', 'D', 'K', 'L', 'M');
first: Augsburg;
last: Monheim;

// succ(duesseldorf) = koeln;
//pred(koeln) = duesseldorf;

implementation

constructor tNachbarn.init;
begin

end;

http://www.wilabs.ch/downloads/pdf/algo.pdf
http://user.cs.tu-berlin.de/~xantippe/Glossar/glossar.html
Spicker_Prolog: Spicker_Prolog

(application/msword, 25 KB)

Spicker_Graphentheorie: Spicker_Graphentheorie

(text/richtext, 21 KB)

Teilmengenproblem

{a,b,c}

{{a,b,c},{a},{b},{c},{a,b},{a,c},{b,c},{}}

KnapSack-Problem (0-1-Problem)

n Objekte Xi € G mit Massen mi (i € [1, N]) und Werten Wi werden in einen Rucksack mit Kapazität M.
Gesucht ist Füllung mit max. Gewinn (∑i Wi maximal)

Beispiel: M=30kg
WarenNr | 1 2 3 4 |
Masse | 15 25 10 20 | kg
Wert | 15 50 40 60 | €
*Spez.Wert | 1 2 4 3 | €/kg

greedy(wert): (4) + (3) => Wert: 100 //+backtracking
greedy(masse): (2) + % => Masse: 50
backtr(masse): (4) + (3) => : 100
greedy(spez.Wert): (3) + (4) : 100

Beispiel:
Nr | 1 2 3 4 5
m | 15 25 10 8 7
W | 45 50 40 28 28
W/m | 3 2 4 3,5 4

greedy(wert): (2) => wert: 50
greedy(masse): (2) => wert: 50
greedy(spez.wert): (3) + (5) + (4) => wert: 96

... kein Bock mehr...

http://www.gymmelk.ac.at/~nus/Delphi/Delphi11.htm

http://www.plauener.de/lessing/delphi/dpue130.htm

http://www.inf.hs-zigr.de/~wagenkn/TI/Komplexitaet/ReferateWS9900/hasht/hasht.html

http://www-lehre.informatik.uni-osnabrueck.de/~ainf/2000/skript/node39.html