斐波那契堆

public class FibHeap 
{
    private FibNode min;
    
    private int count;
    
    private FibNode root;

    
    public FibHeap() 
    {
        root = new FibNode();
        root.left  = root;
        root.right = root;
    }

    /*
     * 返回最小节点
     */
    public FibNode min() 
    {
        return min;
    }

    /*
     * 删除节点
     */
    public void delete(FibNode node) 
    {
        decereaseKey(node, Integer.MIN_VALUE);
        extractMin();
    }
    
    /*
     * 减小某结点的值
     */
    public void decereaseKey(FibNode node, int k) 
    {
        if (node.key < k) {
            throw new RuntimeException("new key is greater than current key");
        }
        
        node.key = k;
        FibNode parent = node.parent;
        if (parent != null && node.key < parent.key) {
            cut(node, parent);
            cascadingCut(parent);
        }
        
        if (node.key < min.key) min = node;
    }

    /*
     * 剔除node节点并执行insertRoot
     */
    public void cut(FibNode node, FibNode parent) 
    {
        node.left.right = node.right;
        node.right.left = node.left;
        parent.degree--;
        
        insertRoot(node);
        node.parent = null;
        node.mark = false;
    }

    /*
     * ?????? 
     */
    public void cascadingCut(FibNode node) 
    {
        FibNode parent = node.parent;
        if (parent != null) {
            if (!node.mark) {
                node.mark = true;
            }
            else {
                cut(node, parent);
                cascadingCut(parent);
            }
        }
    }

    /*
     * 抽取最小关键子节点
     */
    public FibNode extractMin() 
    {
        FibNode node = min;
        if (node != null) {
            
            if (node.degree != 0) {
                FibNode child = node.child;
                FibNode next = child;
                
                do {
                    next.parent = null;
                    next = next.right;
                }
                while (child != next);
                
                node.left.right = child.right;
                child.right.left = node.left;
                node.right.left = child;
                child.right = node.right;
            }
            else {
                node.left.right = node.right;
                node.right.left = node.left;
            }
            
            if (node == node.right) {
                min = null;
            }
            else {
                min = min.right;
                consolidate();
            }
            count--;
        }
        return node;
    }

    /*
     * 输出根节点
     */
    public void displayRoot() 
    {
        FibNode node = root.right;
        while (node != root) {
            System.out.println(node.key);
            node = node.right;
        }
    }

    /*
     * 合并
     */
    public void consolidate() 
    {
        FibNode[] array = new FibNode[(int) (Math.log(count) / Math.log(2)) + 1];
        
        FibNode node = root.right;
        while (node != root) {
            FibNode nodex = node;
            node = node.right;
            int degree = nodex.degree;
            
            while (array[degree] != null) {
                FibNode nodey = array[degree];
                if (nodex.key > nodey.key) {
                    // swap
                    FibNode temp = nodex;
                    nodex = nodey;
                    nodey = temp;
                }
                link(nodey, nodex);
                array[degree++] = null;
            }
            array[degree] = nodex;
        }
        
        min = null;
        for (int i = 0; i < array.length; i++) {
            if (array[i] != null) {
                if (min == null || array[i].key < min.key) {
                    min = array[i];
                }
            }
        }
    }

    /*
     * 连接节点
     */
    public void link(FibNode node, FibNode parent) 
    {
        node.left.right = node.right;
        node.right.left = node.left;
        node.parent = parent;
        
        if (parent.degree == 0) {
            parent.child = node;
            node.left = node;
            node.right = node;
        }
        else {
            node.left = parent.child.left;
            parent.child.left.right = node;
            node.right = parent.child;
            parent.child.left = node;
        }
        
        parent.degree++;
        node.mark = false;
    }

    /*
     * 插入节点
     */
    public void insert(FibNode node) 
    {
        node.degree = 0;
        node.parent = null;
        node.child = null;
        node.left = node;
        node.right = node;
        node.mark = false;
        
        insertRoot(node);
        
        if (min == null || node.key < min.key) {
            min = node;
        }
        count++;
    }

    /*
     * 合并两个堆
     */
    public void union(FibHeap heap) 
    {
        if (heap.count == 0) return;

        FibNode node = heap.root;
        node.right.left = root.left;
        root.left.right = node.right;
        node.left.right = root;
        root.left.left = node;
        
        if (min == null || heap.min.key < min.key) {
            min = heap.min;
        }
        count += heap.count;
    }

    /*
     * 插入Root节点
     */
    private void insertRoot(FibNode node) 
    {
        /*
         *  left  node  root
         *    O-----O-----O
         */
        
        node.left = root.left;
        root.left.right = node;
        node.right = root;
        root.left = node;
    }

    static class FibNode 
    {
        FibNode child;
        
        FibNode left;
        
        FibNode right;
        
        FibNode parent;
        
        int degree = 0;
        
        boolean mark = false;
        
        int key;
        
        
        public FibNode() {}
        
        public FibNode(int key)
        {
            this.key = key;
        }
    }

    public static void main(String[] args) 
    {
        FibHeap fh = new FibHeap();
        
        int[] keys = { 9, 10, 5, 14, 12, 13, 8, 3 };
        for (int i = 0; i < keys.length; i++) {
            fh.insert(new FibNode(keys[i]));
        }
        
        FibHeap fh2 = new FibHeap();
        
        int[] keys2 = { 3,7,2,7,9,14,66};
        for (int i = 0; i < keys2.length; i++) {
            FibNode fn=new FibNode();
            fh2.insert(new FibNode(keys2[i]));
        }
        
        fh.union(fh2);
        System.out.println(fh.min().key);
        
        fh.displayRoot();
        System.out.println("min:" + fh.extractMin().key);
        System.out.println("min:" + fh.extractMin().key);
        System.out.println("min:" + fh.extractMin().key);

        fh.delete(fh.min());
        System.out.println(fh.min().key);
    }
}