斜堆(一)之 C語言的實現

 

概要

本章介紹斜堆。和以往一樣，本文會先對斜堆的理論知識進行簡單介紹，然后給出C語言的實現。后續再分別給出C++和Java版本的實現；實現的語言雖不同，但是原理如出一轍，選擇其中之一進行了解即可。若文章有錯誤或不足的地方，請不吝指出！

目錄
1. 斜堆的介紹
2. 斜堆的基本操作
3. 斜堆的C實現(完整源碼)
4. 斜堆的C測試程序

轉載請注明出處：http://www.cnblogs.com/skywang12345/p/3638493.html

---

更多內容：數據結構與算法系列 目錄

 

斜堆的介紹

斜堆(Skew heap)也叫自適應堆(self-adjusting heap)，它是左傾堆的一個變種。和左傾堆一樣，它通常也用於實現優先隊列。它的合並操作的時間復雜度也是O(lg n)。

相比於左傾堆，斜堆的節點沒有"零距離"這個屬性。除此之外，它們斜堆的合並操作也不同。斜堆的合並操作算法如下：
(01) 如果一個空斜堆與一個非空斜堆合並，返回非空斜堆。
(02) 如果兩個斜堆都非空，那么比較兩個根節點，取較小堆的根節點為新的根節點。將"較小堆的根節點的右孩子"和"較大堆"進行合並。
(03) 合並后，交換新堆根節點的左孩子和右孩子。
        第(03)步是斜堆和左傾堆的合並操作差別的關鍵所在，如果是左傾堆，則合並后要比較左右孩子的零距離大小，若右孩子的零距離 > 左孩子的零距離，則交換左右孩子；最后，在設置根的零距離。

 

斜堆的基本操作

1. 頭文件

#ifndef _SKEW_HEAP_H_
#define _SKEW_HEAP_H_

typedef int Type;

typedef struct _SkewNode{
    Type   key;                // 關鍵字(鍵值)
    struct _SkewNode *left;    // 左孩子
    struct _SkewNode *right;   // 右孩子
}SkewNode, *SkewHeap;

// 前序遍歷"斜堆"
void preorder_skewheap(SkewHeap heap);
// 中序遍歷"斜堆"
void inorder_skewheap(SkewHeap heap);
// 后序遍歷"斜堆"
void postorder_skewheap(SkewHeap heap);

// 獲取最小值(保存到pval中)，成功返回0，失敗返回-1。
int skewheap_minimum(SkewHeap heap, int *pval);
// 合並"斜堆x"和"斜堆y"，並返回合並后的新樹
SkewNode* merge_skewheap(SkewHeap x, SkewHeap y);
// 將結點插入到斜堆中，並返回根節點
SkewNode* insert_skewheap(SkewHeap heap, Type key);
// 刪除結點(key為節點的值)，並返回根節點
SkewNode* delete_skewheap(SkewHeap heap);

// 銷毀斜堆
void destroy_skewheap(SkewHeap heap);

// 打印斜堆
void print_skewheap(SkewHeap heap);

#endif

SkewNode是斜堆對應的節點類。

 

2. 合並

/* 
 * 合並"斜堆x"和"斜堆y"
 *
 * 返回值：
 *     合並得到的樹的根節點
 */
SkewNode* merge_skewheap(SkewHeap x, SkewHeap y)
{
    if(x == NULL)
        return y;
    if(y == NULL)
        return x;

    // 合並x和y時，將x作為合並后的樹的根；
    // 這里的操作是保證: x的key < y的key
    if(x->key > y->key)
        swap_skewheap_node(x, y);

    // 將x的右孩子和y合並，
    // 合並后直接交換x的左右孩子，而不需要像左傾堆一樣考慮它們的npl。
    SkewNode *tmp = merge_skewheap(x->right, y);
    x->right = x->left;
    x->left  = tmp;

    return x;
}

merge_skewheap(x, y)的作用是合並x和y這兩個斜堆，並返回得到的新堆。merge_skewheap(x, y)是遞歸實現的。

 

3. 添加

/* 
 * 新建結點(key)，並將其插入到斜堆中
 *
 * 參數說明：
 *     heap 斜堆的根結點
 *     key 插入結點的鍵值
 * 返回值：
 *     根節點
 */
SkewNode* insert_skewheap(SkewHeap heap, Type key)
{
    SkewNode *node;    // 新建結點

    // 如果新建結點失敗，則返回。
    if ((node = (SkewNode *)malloc(sizeof(SkewNode))) == NULL)
        return heap;
    node->key = key;
    node->left = node->right = NULL;

    return merge_skewheap(heap, node);
}

insert_skewheap(heap, key)的作用是新建鍵值為key的結點，並將其插入到斜堆中，並返回堆的根節點。

 

4. 刪除

/* 
 * 取出根節點
 *
 * 返回值：
 *     取出根節點后的新樹的根節點
 */
SkewNode* delete_skewheap(SkewHeap heap)
{
    SkewNode *l = heap->left;
    SkewNode *r = heap->right;

    // 刪除根節點
    free(heap);

    return merge_skewheap(l, r); // 返回左右子樹合並后的新樹
}

delete_skewheap(heap)的作用是刪除斜堆的最小節點，並返回刪除節點后的斜堆根節點。

 

注意：關於斜堆的"前序遍歷"、"中序遍歷"、"后序遍歷"、"打印"、"銷毀"等接口就不再單獨介紹了。后文的源碼中有給出它們的實現代碼，Please RTFSC(Read The Fucking Source Code)！

 

斜堆的C實現(完整源碼)

斜堆的頭文件(skewheap.h)

#ifndef _SKEW_HEAP_H_
#define _SKEW_HEAP_H_

typedef int Type;

typedef struct _SkewNode{
    Type   key;                    // 關鍵字(鍵值)
    struct _SkewNode *left;    // 左孩子
    struct _SkewNode *right;    // 右孩子
}SkewNode, *SkewHeap;

// 前序遍歷"斜堆"
void preorder_skewheap(SkewHeap heap);
// 中序遍歷"斜堆"
void inorder_skewheap(SkewHeap heap);
// 后序遍歷"斜堆"
void postorder_skewheap(SkewHeap heap);

// 獲取最小值(保存到pval中)，成功返回0，失敗返回-1。
int skewheap_minimum(SkewHeap heap, int *pval);
// 合並"斜堆x"和"斜堆y"，並返回合並后的新樹
SkewNode* merge_skewheap(SkewHeap x, SkewHeap y);
// 將結點插入到斜堆中，並返回根節點
SkewNode* insert_skewheap(SkewHeap heap, Type key);
// 刪除結點(key為節點的值)，並返回根節點
SkewNode* delete_skewheap(SkewHeap heap);

// 銷毀斜堆
void destroy_skewheap(SkewHeap heap);

// 打印斜堆
void print_skewheap(SkewHeap heap);

#endif

斜堆的實現文件(skewheap.c)

/**
 * C語言實現的斜堆
 *
 * @author skywang
 * @date 2014/03/31
 */

#include <stdio.h>
#include <stdlib.h>
#include "skewheap.h"

/*
 * 前序遍歷"斜堆"
 */
void preorder_skewheap(SkewHeap heap)
{
    if(heap != NULL)
    {
        printf("%d ", heap->key);
        preorder_skewheap(heap->left);
        preorder_skewheap(heap->right);
    }
}

/*
 * 中序遍歷"斜堆"
 */
void inorder_skewheap(SkewHeap heap)
{
    if(heap != NULL)
    {
        inorder_skewheap(heap->left);
        printf("%d ", heap->key);
        inorder_skewheap(heap->right);
    }
}

/*
 * 后序遍歷"斜堆"
 */
void postorder_skewheap(SkewHeap heap)
{
    if(heap != NULL)
    {
        postorder_skewheap(heap->left);
        postorder_skewheap(heap->right);
        printf("%d ", heap->key);
    }
}

/*
 * 交換兩個節點的內容
 */
static void swap_skewheap_node(SkewNode *x, SkewNode *y)
{
    SkewNode tmp = *x;
    *x = *y;
    *y = tmp;
}

/* 
 * 獲取最小值
 *
 * 返回值：
 *    成功返回0，失敗返回-1
 */
int skewheap_minimum(SkewHeap heap, int *pval)
{
    if (heap == NULL)
        return -1;

    *pval = heap->key;

    return 0;
}
 
/* 
 * 合並"斜堆x"和"斜堆y"
 *
 * 返回值：
 *     合並得到的樹的根節點
 */
SkewNode* merge_skewheap(SkewHeap x, SkewHeap y)
{
    if(x == NULL)
        return y;
    if(y == NULL)
        return x;

    // 合並x和y時，將x作為合並后的樹的根；
    // 這里的操作是保證: x的key < y的key
    if(x->key > y->key)
        swap_skewheap_node(x, y);

    // 將x的右孩子和y合並，
    // 合並后直接交換x的左右孩子，而不需要像左傾堆一樣考慮它們的npl。
    SkewNode *tmp = merge_skewheap(x->right, y);
    x->right = x->left;
    x->left  = tmp;

    return x;
}

/* 
 * 新建結點(key)，並將其插入到斜堆中
 *
 * 參數說明：
 *     heap 斜堆的根結點
 *     key 插入結點的鍵值
 * 返回值：
 *     根節點
 */
SkewNode* insert_skewheap(SkewHeap heap, Type key)
{
    SkewNode *node;    // 新建結點

    // 如果新建結點失敗，則返回。
    if ((node = (SkewNode *)malloc(sizeof(SkewNode))) == NULL)
        return heap;
    node->key = key;
    node->left = node->right = NULL;

    return merge_skewheap(heap, node);
}

/* 
 * 取出根節點
 *
 * 返回值：
 *     取出根節點后的新樹的根節點
 */
SkewNode* delete_skewheap(SkewHeap heap)
{
    SkewNode *l = heap->left;
    SkewNode *r = heap->right;

    // 刪除根節點
    free(heap);

    return merge_skewheap(l, r); // 返回左右子樹合並后的新樹
}

/*
 * 銷毀斜堆
 */
void destroy_skewheap(SkewHeap heap)
{
    if (heap==NULL)
        return ;

    if (heap->left != NULL)
        destroy_skewheap(heap->left);
    if (heap->right != NULL)
        destroy_skewheap(heap->right);

    free(heap);
}

/*
 * 打印"斜堆"
 *
 * heap       -- 斜堆的節點
 * key        -- 節點的鍵值 
 * direction  --  0，表示該節點是根節點;
 *               -1，表示該節點是它的父結點的左孩子;
 *                1，表示該節點是它的父結點的右孩子。
 */
static void skewheap_print(SkewHeap heap, Type key, int direction)
{
    if(heap != NULL)
    {
        if(direction==0)    // heap是根節點
            printf("%2d is root\n", heap->key);
        else                // heap是分支節點
            printf("%2d is %2d's %6s child\n", heap->key, key, direction==1?"right" : "left");

        skewheap_print(heap->left, heap->key, -1);
        skewheap_print(heap->right,heap->key,  1);
    }
}

void print_skewheap(SkewHeap heap)
{
    if (heap != NULL)
        skewheap_print(heap, heap->key,  0);
}

斜堆的測試程序(skewheap_test.c)

/**
 * C語言實現的斜堆
 *
 * @author skywang
 * @date 2014/03/31
 */

#include <stdio.h>
#include "skewheap.h"

#define LENGTH(a) ( (sizeof(a)) / (sizeof(a[0])) )

void main()
{
    int i;
    int a[]= {10,40,24,30,36,20,12,16};
    int b[]= {17,13,11,15,19,21,23};
    int alen=LENGTH(a);
    int blen=LENGTH(b);
    SkewHeap ha,hb;

    ha=hb=NULL;

    printf("== 斜堆(ha)中依次添加: ");
    for(i=0; i<alen; i++)
    {
        printf("%d ", a[i]);
        ha = insert_skewheap(ha, a[i]);
    }
    printf("\n== 斜堆(ha)的詳細信息: \n");
    print_skewheap(ha);


    printf("\n== 斜堆(hb)中依次添加: ");
    for(i=0; i<blen; i++)
    {
        printf("%d ", b[i]);
        hb = insert_skewheap(hb, b[i]);
    }
    printf("\n== 斜堆(hb)的詳細信息: \n");
    print_skewheap(hb);

    // 將"斜堆hb"合並到"斜堆ha"中。
    ha = merge_skewheap(ha, hb);
    printf("\n== 合並ha和hb后的詳細信息: \n");
    print_skewheap(ha);


    // 銷毀斜堆
    destroy_skewheap(ha);
}

 

斜堆的C測試程序

斜堆的測試程序已經包含在它的實現文件(skewheap_test.c)中了，這里僅給出它的運行結果：

== 斜堆(ha)中依次添加: 10 40 24 30 36 20 12 16 
== 斜堆(ha)的詳細信息: 
10 is root
16 is 10's   left child
20 is 16's   left child
30 is 20's   left child
40 is 30's   left child
12 is 10's  right child
24 is 12's   left child
36 is 24's   left child

== 斜堆(hb)中依次添加: 17 13 11 15 19 21 23 
== 斜堆(hb)的詳細信息: 
11 is root
13 is 11's   left child
17 is 13's   left child
23 is 17's   left child
19 is 13's  right child
15 is 11's  right child
21 is 15's   left child

== 合並ha和hb后的詳細信息: 
10 is root
11 is 10's   left child
12 is 11's   left child
15 is 12's   left child
21 is 15's   left child
24 is 12's  right child
36 is 24's   left child
13 is 11's  right child
17 is 13's   left child
23 is 17's   left child
19 is 13's  right child
16 is 10's  right child
20 is 16's   left child
30 is 20's   left child
40 is 30's   left child