java实现裴波那契堆

package tree;

public class FibHeap {

public Node min;
public int count;

public static class Node {
protected int key;
protected Node parent;
protected Node child;
protected Node left;
protected Node right;
protected int degree;
protected boolean mark;

public Node(int key) {
this.key = key;
this.right = this.left = this;
}
}

public static void beforeInsert(Node current, Node node) {
current.left.right = node;
node.left = current.left;
current.left = node;
node.right = current;
}

public static void insert(FibHeap heap, Node node) {
node.mark = false;
if (heap.min == null) {
heap.min = node;
node.left = node.right = node;
} else {
beforeInsert(heap.min, node);
if (node.key < heap.min.key)
heap.min = node;
}
heap.count++;
}

public static FibHeap union(FibHeap heap1, FibHeap heap2) {
FibHeap heap = new FibHeap();
FibHeap other;
if (heap1.min != null) {
heap = heap1;
other = heap2;
} else if (heap2.min != null) {
heap = heap2;
other = heap1;
} else
return heap;
heap.count += other.count;
if (other.count != 0) {
Node temp1 = heap.min.left;
Node temp2 = other.min.left;
temp2.right = heap.min;
heap.min.left = temp2;
temp1.right = other.min;
other.min.right = temp1;
if (other.min.key < heap.min.key)
heap.min = other.min;
}
return heap;
}

public static Node extractMin(FibHeap heap) {
Node min = heap.min;
if (min != null) {
while (min.child != null) {
Node child = min.child;
Node right = child.right;
Node heapMinRight = heap.min.right;
heap.min.right = child;
child.left = heap.min;
heapMinRight.left = child;
child.right = heapMinRight;
child.parent = null;
heap.count++;
//child.mark = false;
if (right != child)
min.child = right;
else {
min.child = null;
break;
}
}
heap.count--;
if (min.right == min) {
heap.min = null;
} else {
heap.min.left.right = heap.min.right;
heap.min.right.left = heap.min.left;
heap.min = heap.min.right;
consolidate(heap);
}
}
return min;
}

private static void consolidate(FibHeap heap) {
int sum_degree = heap.min.degree;
Node node = heap.min.left;
if (heap.count > 1)
while (node != heap.min) {
sum_degree += node.degree;
node = node.left;
}
Node[] nodeArray = new Node[sum_degree];
A:
while (true) {
if (nodeArray[node.degree] == null) {
nodeArray[node.degree] = node;
node = node.left;
} else if (!node.equals(nodeArray[node.degree])) {
int d = node.degree;
while (nodeArray[d] != null) {
node = nodeArray[node.degree].key > node.key
? heapLink(heap, nodeArray[node.degree], node)
: heapLink(heap, node, nodeArray[node.degree]);
nodeArray[d++] = null;
}
nodeArray[d] = node;
node = node.left;
} else {
Node current = node;
node = node.left;
while (true)
if (node.equals(current))
break A;
else if (nodeArray[node.degree] == null || !node.equals(nodeArray[node.degree]))
break;
else
node = node.left;
}
}
Node min_temp = node;
heap.min = node;
heap.count = 1;
while (true) {
if (min_temp.key > node.key)
min_temp = node;
node = node.left;
if (node == heap.min)
break;
heap.count++;
}
heap.min = min_temp;
}

public static void decreaseKey(FibHeap heap, Node x, int key) throws Exception {
if (key > x.key)
throw new Exception("key must great then x.key !");
x.key = key;
Node y = x.parent;
if (y != null && x.key < y.key) {
cut(heap, x, y);
cascadingCut(heap, y);
}
if (heap.min.key < x.key)
heap.min = x;
}

private static void cut(FibHeap heap, Node x, Node y) {
x.left.right = x.right;
x.right.left = x.left;
y.degree--;
Node minRight = heap.min.right;
minRight.left = x;
heap.min.right = x;
x.left = heap.min;
x.right = minRight;
x.parent = null;
x.mark = false;
}

private static void cascadingCut(FibHeap heap, Node y) {
Node z = y.parent;
if (z != null)
if (!y.mark)
y.mark = true;
else {
cut(heap, y, z);
cascadingCut(heap, z);
}
}

public static void delete(FibHeap heap, Node node) {
try {
decreaseKey(heap,node,Integer.MIN_VALUE);
} catch (Exception e) {
}
extractMin(heap);
}
private static Node heapLink(FibHeap heap, Node other, Node tempNode) {
other.left.right = other.right;
other.right.left = other.left;
other.parent = tempNode;
tempNode.child.right.left = other;
tempNode.child.right = other;
other.right = tempNode.child.right;
other.left = tempNode;
tempNode.degree++;
other.mark = false;
return tempNode;
}
}