1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

  TFeld=Array of Byte;
  TEntry=record
    X,Y,
    F //Gesammt Kosten
    ,G //Kosten Start->Punkt
    ,H:Integer; //Kosten Punkt->Ziel
    offen:DWORD;
    preKnoten:Integer;
  end;
  PEntry=^TEntry;
  TFeld2=Array of TEntry;
  PList=^TList;
  TList=record
    iFeld:Integer;
    next:PList;
  end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:

type
    TRingPufferEntry = Integer;
    TRingpufferData = array of TRingPufferEntry;
    TRingpuffer = record
        data: TRingPufferData;
        head: Integer;
        tail: Integer;
        itemcount: Integer //Optional: Anzahl der Einträge grad, kann entfallen.
    end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:

public class BinaryHeap {
    private int[]       keys;
    private Node[]      values;
    private int         initialSize = 16;
    private int         last;
    private int         size;
    public BinaryHeap(){
        keys        = new int[initialSize];
        values      = new Node[initialSize];
        last        = 0;
        size        = initialSize;
    }
    public boolean isEmpty(){
        return last == 0;
    }
    public void insert(int key, Node node){
        /*=== resize if array is full ===*/
        if(last+1 == keys.length){
            resize(2*keys.length, keys.length);
        }
        last++;
        keys[last]          = key;
        values[last]        = node;
        node.indexOnList    = last;
        upheap(last);
    }
    public Node min(){
        return values[1];
    }
    public Node removeMin(){
        Node result     = values[1];
        keys[1]         = keys[last];
        values[1]       = values[last];
        last--;
        downheap(1);
        /*=== resize if the array's almost empty ===*/
        if(last<size/4 && last >= initialSize){
            resize(size/2, size);
        }
        return result;
    }
    private void downheap(int index){
        if(index < last){
            int lSun = index*2;
            int rSun = lSun+1;
            int minSun;
            if(rSun<=last){
                if(keys[rSun]<keys[lSun]){
                    minSun = rSun;
                }
                else{
                    minSun = lSun;
                }
                if(keys[minSun]<keys[index]){
                    swap(keys, minSun, index);
                    swap(values, minSun, index);
                    downheap(minSun);
                }
            }
            else if (lSun<=last){
                if(keys[lSun]<keys[index]){
                    swap(keys, lSun, index);
                    swap(values, lSun, index);
                    downheap(lSun);
                }
            }
        }
    }
    private void upheap(int index){
        if(index>1){
            int father = index/2;
            if(keys[father] > keys[index]){
                swap(keys, father, index);
                swap(values, father, index);
                upheap(father);
            }
        }
    }
    private void swap(int[] arr, int a, int b){
        int tmp     = arr[a];
        arr[a]      = arr[b];
        arr[b]      = tmp;
    }
    private void swap(Node[] arr, int a, int b){
        /*=== swap the Nodes: ===*/
        Node tmp                = arr[a];
        arr[a]                  = arr[b];
        arr[b]                  = tmp;
        /*=== swap the indices, too ===*/
        arr[a].indexOnList      = a;
        arr[b].indexOnList      = b;
    }
    private void resize(int newSize, int oldSize){
        int[]   arr   = new int[newSize];
        Node[]  arr2  = new Node[newSize];
        size        = newSize;
        int n       = min(newSize, oldSize);
        for(int i=0 ; i<n ; i++){
            arr[i]  = keys[i];
            arr2[i] = values[i];
        }
        keys    = arr;
        values  = arr2;
    }
    private int min(int a, int b){
        if(a<b) return a;
        return b;
    }
    public int size(){
        return last;
    }
    public void changeDist(Node node, int newDist){
        node.dist               = newDist;
        keys[node.indexOnList]  = newDist;
        upheap(node.indexOnList);
        downheap(node.indexOnList);
    }
}