斐波那契堆(Fibonacci heap)原理詳解(附java代碼實現)

前言

　　斐波那契堆(Fibonacci heap)是計算機科學中最小堆有序樹的集合。它和二項式堆有類似的性質，但比二項式堆有更好的均攤時間。堆的名字來源於斐波那契數，它常用於分析運行時間。

     

 

 

堆結構介紹

　　基本術語介紹：

　　關鍵字：堆節點儲存的用於比較的信息

　　度數：堆節點擁有的孩子數(注意，不包括孩子的孩子)

　　左兄弟：節點左邊的兄弟節點

　　右兄弟：節點右邊的兄弟節點

　　mark:是否有孩子節點被刪除

 

　　斐波那契堆是一系列無序樹的集合，每棵樹是一個最小堆，滿足最小堆的性質。(注意，樹是無序的，所以不要糾結樹該怎么排序)。堆保存了堆中所有節點的數目，保存了最小關鍵字的節點(這是整個堆的唯一入口，根據這個最小節點可以獲取整個堆的任何節點)。

　　堆的節點是堆的最小單位，它是雙向鏈表的節點，意味着它保存了上下節點的信息，如下圖,(也能看出樹的根節點排列是無序的)。

　　

　　它主要有如下性質：

　　1、關鍵字

　　2、度數

　　3、左兄弟

　　4、右兄弟

　　5、父節點

　　6、孩子節點(任一個孩子節點，隨意)

 

堆基本操作

　　一、插入操作

　　　　1、創建一個節點，如21

　　

　　2、把新建的節點插入到根鏈表中，如果是最小值，則更新它為堆的最小節點。插入位置沒有規定，一般習慣插入到min的左邊。把堆的“所有節點數”值加1

　　

　　3、插入操作完成了(插入並不會對堆進行修改，修改是在其他操作中進行的，所以比較簡單)

 

　　二、刪除最小節點

　　　　1、刪除最小節點，並把它的所有孩子合並到堆的根鏈表中，並更新min

 

　　2、合並根節點的樹，使任何樹的度(rank)不相等

　　　　觀察到7有1個孩子節點，即度為1，先保存起來，由於是初始的，肯定沒有和7度相同的

　　　　接着下一個根節點24，度為2，繼續。

　　　　23, 度為1，繼續

　　　　17, 度為1。 由於已經有度為1的根節點了，所以需要合並這兩個節點

　　　　根據最小堆得性質，把23合並到17上，作為17的孩子節點

　　　　此時17的度為2，仍然重復，繼續合並，直到沒有度一樣的根節點

 

　　　　最終結果如下圖

 

　　　　

 

　　三、減小key值

　　　　如果沒有違背最小堆的性質，直接減小key的值

　　　　否則，把以key為根節點的樹合並到堆的根鏈表中

　　　　如果有一個節點有兩個孩子移除了，把這個節點也合並到根鏈表中，並且unmark它

　　　　

　　　　現在舉一個例子來說明各種可能情況

　　　　1、不違反最小堆性質

　　　　　　把46減小為29，不違反最小堆性質，不改變堆結構

　　

　　　　2、違反最小堆性質，合並到根鏈表中，並且unmark 它

　　　　　　把29減小為15，違反了堆性質

　　

　　　　把15合並到根鏈表中

　　如果父節點沒有mark(沒有失去孩子), 設置它為mark

　　

　　如果父節點已經是mark，則把父節點合並到根鏈表中，並設置為unmark。

　　把節點35減小到5　

　　

　　由於違反了，把5合並到根

　　由於26已經mark，把26這個子樹合並到根

　　同理24合並到根

　　由於7已經是根節點了，停止，全部結束

　　四、刪除節點

　　　　刪除節點比較簡單，主要分為兩步

　　　　1、把節點值decrease比堆最小值還小

　　　　2、刪除最小值

 

java代碼實現(僅供參考，邏輯並不十分嚴謹)

 

public class FibonNode<T extends Comparable<T>> {

    public T key;
    
    public FibonNode<T> child;
    
    public FibonNode<T> left;
    
    public FibonNode<T> right;
    
    public boolean mark;
    
    public FibonNode<T> parent;
    
    public int degree;
    
    public FibonNode(T key){
        this.degree = 0;
        this.key = key;
        this.parent = null;
        this.child = null;
        this.left = null;
        this.right = null;
        this.mark = false;
    }
}

 

 

 

 

public class FibonHeap<T extends Comparable<T>> {

    private int keyNum;

    private FibonNode<T> min;

    /*
     * 保存當前指針
     */
    private FibonNode<T> current;

    /*
     * 保存各個度對應的節點,如度為1的節點對應的節點
     */
    private Map<Integer, FibonNode<T>> degreeNodes;

    public FibonHeap(T key) {
        min = new FibonNode<T>(key);
        keyNum += 1;
        min.left = min;
        min.right = min;
    }

    /*
     * 插入值
     */
    public void insert(T key) {
        FibonNode<T> node = new FibonNode<T>(key);
        insert(node);
    }

    
    /*
     * 刪除最小值
     */
    public void deleteMin() {
        degreeNodes = new HashMap<Integer, FibonNode<T>>();
        removeMinNode();
        consolidate();

    }
    
    /*
     * 刪除節點
     */
    public void deleteNode(FibonNode<T> node){
        T everSmall = null;
        decrease(node, everSmall);
        deleteMin();
    }
    
    /*
     * 合並堆
     */
    public FibonHeap<T> union(FibonHeap<T> heapA, FibonHeap<T> heapB){
        FibonNode<T> minA = heapA.min;
        FibonNode<T> minB = heapB.min;
        minA.right = minB;
        minA.right.left = minB.right;
        minB.left = minA;
        minB.right.left = minA.right;
        FibonNode<T> min = minA;
        if(minB.key.compareTo(minB.key) < 0){
            min = minB;
        }
        heapA.min = min;
        heapA.keyNum += heapB.keyNum;
        return heapA;
    }
    
    private void insert(FibonNode<T> node) {
        //插入就是直接更新左右節點就可以了
        min.left.right = node;
        node.left = min.left;
        node.right = min;
        min.left = node;
        T minKey = min.key;
        if (node.key.compareTo(minKey) < 0) {
            min = node;
        }
        keyNum += 1;
    }
    
    /*
     * 把節點從堆中刪除
     */
    private void removeMinNode() {
        FibonNode<T> left = min.left;
        if (left == min) {
            //說明只剩最后一個節點了，也就是最小節點自己
            if (min.child != null) {
                min = null;//這里不是null，應該是孩子節點中最小節點，筆者沒有寫完而已
            }
        } else {
            deleteInList(min);
            addChToR(min);
            min = left;    //    先隨意選個節點作為最小節點，在隨后環節會更新的
        }
        keyNum--;
    }


    /*
     * 把根節點合並使其所有節點的度不相等
     */
    private void consolidate() {
        current = min;
        do {
            current = putDegreeNodes(current);
            if (current.key.compareTo(min.key) < 0) {
                min = current;
            }
            current = current.right;
        } while (current != min && current.left != current);
    }

    /*
     * 
     */
    private FibonNode<T> putDegreeNodes(FibonNode<T> node) {
        int nodeDegree = node.degree;
        //從map中找節點對應的度是否存在，存在說明有相同度的節點了，需要合並
        FibonNode<T> nodeInMap = degreeNodes.get(nodeDegree);    
        if (nodeInMap == null) {
            degreeNodes.put(nodeDegree, node);
        } else {
            if (node.key.compareTo(nodeInMap.key) < 0) {
                deleteInList(nodeInMap);
                nodeInMap.left = nodeInMap;
                nodeInMap.right = nodeInMap;
                node = fibLink(node, nodeInMap);
                nodeInMap = node;
            } else {
                deleteInList(node);
                node.left = node;
                node.right = node;
                nodeInMap = fibLink(nodeInMap, node);

                node = nodeInMap;
            }
            degreeNodes.put(nodeDegree, null);
            node = putDegreeNodes(node);
        }
        return node;
    }

    private FibonNode<T> fibLink(FibonNode<T> parent, FibonNode<T> child) {
        if (parent.child == null) {
            parent.child = child;
            
        } else {
            parent.child = insertCyle(parent.child, child);
        }
        child.parent = parent;
        parent.degree += 1;
        return parent;
    }

    /*
     * 從所在鏈中刪除
     */
    private void deleteInList(FibonNode<T> node) {
        FibonNode<T> left = node.left;
        FibonNode<T> right = node.right;
        left.right = right;
        right.left = left;
    }

    /*
     * 插入到鏈中
     */
    private FibonNode<T> insertCyle(FibonNode<T> target, FibonNode<T> node) {
        FibonNode<T> left = target.left;
        left.right = node;
        node.left = target;
        node.right = target;
        target.left = node;
        return target;
    }

    /*
     * 把孩子節點添加到根鏈表中
     */
    private void addChToR(FibonNode<T> node) {
        FibonNode<T> aChild = node.child;
        if (aChild == null) {
            return;
        }
        do {
            //孩子節點循環插入根
            FibonNode<T> right = aChild.right;
            min.right = insertCyle(min.right, aChild);
            aChild = right;

        } while (aChild != node.child);
    }
    
    public void decrease(FibonNode<T> target, T key){
        FibonNode<T> parent = target.parent;
        if(target.key.compareTo(key) < 0){
            System.out.println("只能減少key值");
            return;
        }
        if(parent == null){
            //如果修改節點是根節點，直接修改
            target.key = key;
            if(key.compareTo(min.key) < 0){
                //更新最小節點
                min = target;
            }
            return;
        }
        if(parent.key.compareTo(key) < 0){
            //如果值修改稿后不違反最小堆，直接修改即可
            target.key = key;
            return;
        }
        cutAndMeld(target);
        parent = cascadingCut(parent);
    }
    
    /*
     * 刪除節點，並合並到根中
     */
    private void cutAndMeld(FibonNode<T> target){
        target.parent = null;
        target.mark = false;
        insert(target);
    }
    
    /*
     * 級聯刪除，使其符合斐波那契堆性質
     */
    private FibonNode<T> cascadingCut(FibonNode<T> parent){
        if(null == parent){
            return null;
        }
        parent.degree--;
        if(parent.mark == false){
            parent.mark = true;
        }else{
            cutAndMeld(parent);
            parent = cascadingCut(parent);
        }
        return parent;
    }
    
    
}

 

 

 

 

參考文獻

　　http://staff.ustc.edu.cn/~csli/graduate/algorithms/book6/chap21.htm

　　斐波那契堆(一)之 圖文解析 和 C語言的實現

　　fibonacci-heap

　　Fibonacci_heap