二叉堆(一)之圖文解析和 C語言的實現

出自：http://www.cnblogs.com/skywang12345/p/3610187.html

概要

本章介紹二叉堆，二叉堆就是通常我們所說的數據結構中"堆"中的一種。和以往一樣，本文會先對二叉堆的理論知識進行簡單介紹，然後給出C語言的實現。後續再分別給出C++和Java版本的實現；實現的語言雖不同，但是原理如出一轍，選擇其中之一進行了解即可。若文章有錯誤或不足的地方，請不吝指出！

目錄
1. 堆和二叉堆的介紹
2. 二叉堆的圖文解析
3. 二叉堆的C實現(完整源碼)
4. 二叉堆的C測試程序

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

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

(01) 二叉堆(一)之圖文解析和 C語言的實現
(02) 二叉堆(二)之 C++的實現
(03) 二叉堆(三)之 Java的實

堆和二叉堆的介紹

堆的定義

堆(heap)，這裏所說的堆是數據結構中的堆，而不是內存模型中的堆。堆通常是一個可以被看做一棵樹，它滿足下列性質：
[性質一] 堆中任意節點的值總是不大於(不小於)其子節點的值；
[性質二] 堆總是一棵完全樹。
將任意節點不大於其子節點的堆叫做最小堆或小根堆，而將任意節點不小於其子節點的堆叫做最大堆或大根堆。常見的堆有二叉堆、左傾堆、斜堆、二項堆、斐波那契堆等等。

二叉堆的定義

二叉堆是完全二元樹或者是近似完全二元樹，它分爲兩種：最大堆和最小堆。
最大堆：父結點的鍵值總是大於或等於任何一個子節點的鍵值；最小堆：父結點的鍵值總是小於或等於任何一個子節點的鍵值。示意圖如下：

二叉堆一般都通過"數組"來實現。數組實現的二叉堆，父節點和子節點的位置存在一定的關係。有時候，我們將"二叉堆的第一個元素"放在數組索引0的位置，有時候放在1的位置。當然，它們的本質一樣(都是二叉堆)，只是實現上稍微有一丁點區別。
假設"第一個元素"在數組中的索引爲 0 的話，則父節點和子節點的位置關係如下：
(01) 索引爲i的左孩子的索引是 (2*i+1);
(02) 索引爲i的左孩子的索引是 (2*i+2);
(03) 索引爲i的父結點的索引是 floor((i-1)/2);

假設"第一個元素"在數組中的索引爲 1 的話，則父節點和子節點的位置關係如下：
(01) 索引爲i的左孩子的索引是 (2*i);
(02) 索引爲i的左孩子的索引是 (2*i+1);
(03) 索引爲i的父結點的索引是 floor(i/2);

注意：本文二叉堆的實現統統都是採用"二叉堆第一個元素在數組索引爲0"的方式！

二叉堆的圖文解析

在前面，我們已經瞭解到："最大堆"和"最小堆"是對稱關係。這也意味着，瞭解其中之一即可。本節的圖文解析是以"最大堆"來進行介紹的。

二叉堆的核心是"添加節點"和"刪除節點"，理解這兩個算法，二叉堆也就基本掌握了。下面對它們進行介紹。

1. 添加

假設在最大堆[90,80,70,60,40,30,20,10,50]種添加85，需要執行的步驟如下：

如上圖所示，當向最大堆中添加數據時：先將數據加入到最大堆的最後，然後儘可能把這個元素往上挪，直到挪不動爲止！
將85添加到[90,80,70,60,40,30,20,10,50]中後，最大堆變成了[90,85,70,60,80,30,20,10,50,40]。

最大堆的插入代碼(C語言)

/*
 * 最大堆的向上調整算法(從start開始向上直到0，調整堆)
 *
 * 注：數組實現的堆中，第N個節點的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 *
 * 參數說明：
 *     start -- 被上調節點的起始位置(一般爲數組中最後一個元素的索引)
 */
static void maxheap_filterup(int start)
{
    int c = start;            // 當前節點(current)的位置
    int p = (c-1)/2;        // 父(parent)結點的位置 
    int tmp = m_heap[c];        // 當前節點(current)的大小

    while(c > 0)
    {
        if(m_heap[p] >= tmp)
            break;
        else
        {
            m_heap[c] = m_heap[p];
            c = p;
            p = (p-1)/2;   
        }       
    }
    m_heap[c] = tmp;
}
  
/* 
 * 將data插入到二叉堆中
 *
 * 返回值：
 *     0，表示成功
 *    -1，表示失敗
 */
int maxheap_insert(int data)
{
    // 如果"堆"已滿，則返回
    if(m_size == m_capacity)
        return -1;
 
    m_heap[m_size] = data;        // 將"數組"插在表尾
    maxheap_filterup(m_size);    // 向上調整堆
    m_size++;                    // 堆的實際容量+1

    return 0;
}

maxheap_insert(data)的作用：將數據data添加到最大堆中。
當堆已滿的時候，添加失敗；否則data添加到最大堆的末尾。然後通過上調算法重新調整數組，使之重新成爲最大堆。

2. 刪除

假設從最大堆[90,85,70,60,80,30,20,10,50,40]中刪除90，需要執行的步驟如下：

從[90,85,70,60,80,30,20,10,50,40]刪除90之後，最大堆變成了[85,80,70,60,40,30,20,10,50]。
如上圖所示，當從最大堆中刪除數據時：先刪除該數據，然後用最大堆中最後一個的元素插入這個空位；接着，把這個“空位”儘量往上挪，直到剩餘的數據變成一個最大堆。

注意：考慮從最大堆[90,85,70,60,80,30,20,10,50,40]中刪除60，執行的步驟不能單純的用它的子節點來替換；而必須考慮到"替換後的樹仍然要是最大堆"！

最大堆的刪除代碼(C語言)

/* 
 * 返回data在二叉堆中的索引
 *
 * 返回值：
 *     存在 -- 返回data在數組中的索引
 *     不存在 -- -1
 */
int get_index(int data)
{
    int i=0;

    for(i=0; i<m_size; i++)
        if (data==m_heap[i])
            return i;

    return -1;
}

/* 
 * 最大堆的向下調整算法
 *
 * 注：數組實現的堆中，第N個節點的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 *
 * 參數說明：
 *     start -- 被下調節點的起始位置(一般爲0，表示從第1個開始)
 *     end   -- 截至範圍(一般爲數組中最後一個元素的索引)
 */
static void maxheap_filterdown(int start, int end)
{
    int c = start;          // 當前(current)節點的位置
    int l = 2*c + 1;     // 左(left)孩子的位置
    int tmp = m_heap[c];    // 當前(current)節點的大小

    while(l <= end)
    {
        // "l"是左孩子，"l+1"是右孩子
        if(l < end && m_heap[l] < m_heap[l+1])
            l++;        // 左右兩孩子中選擇較大者，即m_heap[l+1]
        if(tmp >= m_heap[l])
            break;        //調整結束
        else
        {
            m_heap[c] = m_heap[l];
            c = l;
            l = 2*l + 1;   
        }       
    }   
    m_heap[c] = tmp;
}

/*
 * 刪除最大堆中的data
 *
 * 返回值：
 *      0，成功
 *     -1，失敗
 */
int maxheap_remove(int data)
{
    int index;
    // 如果"堆"已空，則返回-1
    if(m_size == 0)
        return -1;

    // 獲取data在數組中的索引
    index = get_index(data); 
    if (index==-1)
        return -1;

    m_heap[index] = m_heap[--m_size];        // 用最後元素填補
    maxheap_filterdown(index, m_size-1);    // 從index位置開始自上向下調整爲最大堆

    return 0;
}

maxheap_remove(data)的作用：從最大堆中刪除數據data。
當堆已經爲空的時候，刪除失敗；否則查處data在最大堆數組中的位置。找到之後，先用最後的元素來替換被刪除元素；然後通過下調算法重新調整數組，使之重新成爲最大堆。

該"示例的完整代碼"以及"最小堆的相關代碼"，請參考下面的二叉堆的實現。

二叉堆的C實現(完整源碼)

二叉堆的實現同時包含了"最大堆"和"最小堆"，它們是對稱關係；理解一個，另一個就非常容易懂了。

二叉堆(最大堆)的實現文件(max_heap.c)

/**
* 二叉堆(最大堆)
*
* @author skywang
* @date 2014/03/07
*/

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

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

static int m_heap[30];        // 數據
static int m_capacity=30;    // 總的容量
static int m_size=0;        // 實際容量(初始化爲0)

/* 
* 返回data在二叉堆中的索引
*
* 返回值：
*     存在 -- 返回data在數組中的索引
*     不存在 -- -1
*/
int get_index(int data)
{
   int i=0;

   for(i=0; i<m_size; i++)
       if (data==m_heap[i])
           return i;

   return -1;
}

/* 
* 最大堆的向下調整算法
*
* 注：數組實現的堆中，第N個節點的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
*
* 參數說明：
*     start -- 被下調節點的起始位置(一般爲0，表示從第1個開始)
*     end   -- 截至範圍(一般爲數組中最後一個元素的索引)
*/
static void maxheap_filterdown(int start, int end)
{
   int c = start;          // 當前(current)節點的位置
   int l = 2*c + 1;     // 左(left)孩子的位置
   int tmp = m_heap[c];    // 當前(current)節點的大小

   while(l <= end)
   {
       // "l"是左孩子，"l+1"是右孩子
       if(l < end && m_heap[l] < m_heap[l+1])
           l++;        // 左右兩孩子中選擇較大者，即m_heap[l+1]
       if(tmp >= m_heap[l])
           break;        //調整結束
       else
       {
           m_heap[c] = m_heap[l];
           c = l;
           l = 2*l + 1;   
       }       
   }   
   m_heap[c] = tmp;
}

/*
* 刪除最大堆中的data
*
* 返回值：
*      0，成功
*     -1，失敗
*/
int maxheap_remove(int data)
{
   int index;
   // 如果"堆"已空，則返回-1
   if(m_size == 0)
       return -1;

   // 獲取data在數組中的索引
   index = get_index(data); 
   if (index==-1)
       return -1;

   m_heap[index] = m_heap[--m_size];        // 用最後元素填補
   maxheap_filterdown(index, m_size-1);    // 從index位置開始自上向下調整爲最大堆

   return 0;
}

/*
* 最大堆的向上調整算法(從start開始向上直到0，調整堆)
*
* 注：數組實現的堆中，第N個節點的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
*
* 參數說明：
*     start -- 被上調節點的起始位置(一般爲數組中最後一個元素的索引)
*/
static void maxheap_filterup(int start)
{
   int c = start;            // 當前節點(current)的位置
   int p = (c-1)/2;        // 父(parent)結點的位置 
   int tmp = m_heap[c];        // 當前節點(current)的大小

   while(c > 0)
   {
       if(m_heap[p] >= tmp)
           break;
       else
       {
           m_heap[c] = m_heap[p];
           c = p;
           p = (p-1)/2;   
       }       
   }
   m_heap[c] = tmp;
}
 
/* 
* 將data插入到二叉堆中
*
* 返回值：
*     0，表示成功
*    -1，表示失敗
*/
int maxheap_insert(int data)
{
   // 如果"堆"已滿，則返回
   if(m_size == m_capacity)
       return -1;

   m_heap[m_size] = data;        // 將"數組"插在表尾
   maxheap_filterup(m_size);    // 向上調整堆
   m_size++;                    // 堆的實際容量+1

   return 0;
}
 
/* 
* 打印二叉堆
*
* 返回值：
*     0，表示成功
*    -1，表示失敗
*/
void maxheap_print()
{
   int i;
   for (i=0; i<m_size; i++)
       printf("%d ", m_heap[i]);
}
   
void main()
{
   int a[] = {10, 40, 30, 60, 90, 70, 20, 50, 80};
   int i, len=LENGTH(a);

   printf("== 依次添加: ");
   for(i=0; i<len; i++)
   {
       printf("%d ", a[i]);
       maxheap_insert(a[i]);
   }

   printf("\n== 最 大 堆: ");
   maxheap_print();

   i=85;
   maxheap_insert(i);
   printf("\n== 添加元素: %d", i);
   printf("\n== 最 大 堆: ");
   maxheap_print();

   i=90;
   maxheap_remove(i);
   printf("\n== 刪除元素: %d", i);
   printf("\n== 最 大 堆: ");
   maxheap_print();
   printf("\n");
}

二叉堆(最小堆)的實現文件(min_heap.c)

/**
* 二叉堆(最小堆)
*
* @author skywang
* @date 2014/03/07
*/

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

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

static int m_heap[30];
static int m_capacity=30;    // 總的容量
static int m_size=0;        // 實際容量(初始化爲0)

/* 
* 返回data在二叉堆中的索引
*
* 返回值：
*     存在 -- 返回data在數組中的索引
*     不存在 -- -1
*/
int get_index(int data)
{
   int i=0;

   for(i=0; i<m_size; i++)
       if (data==m_heap[i])
           return i;

   return -1;
}

/* 
* 最小堆的向下調整算法
*
* 注：數組實現的堆中，第N個節點的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
*
* 參數說明：
*     start -- 被下調節點的起始位置(一般爲0，表示從第1個開始)
*     end   -- 截至範圍(一般爲數組中最後一個元素的索引)
*/
static void minheap_filterdown(int start, int end)
{
   int c = start;          // 當前(current)節點的位置
   int l = 2*c + 1;     // 左(left)孩子的位置
   int tmp = m_heap[c];    // 當前(current)節點的大小

   while(l <= end)
   {
       // "l"是左孩子，"l+1"是右孩子
       if(l < end && m_heap[l] > m_heap[l+1])
           l++;        // 左右兩孩子中選擇較小者，即m_heap[l+1]
       if(tmp <= m_heap[l])
           break;        //調整結束
       else
       {
           m_heap[c] = m_heap[l];
           c = l;
           l = 2*l + 1;   
       }       
   }   
   m_heap[c] = tmp;
}

/*
* 刪除最小堆中的data
*
* 返回值：
*      0，成功
*     -1，失敗
*/
int minheap_remove(int data)
{
   int index;
   // 如果"堆"已空，則返回-1
   if(m_size == 0)
       return -1;

   // 獲取data在數組中的索引
   index = get_index(data); 
   if (index==-1)
       return -1;

   m_heap[index] = m_heap[--m_size];        // 用最後元素填補
   minheap_filterdown(index, m_size-1);    // 從index號位置開始自上向下調整爲最小堆

   return 0;
}

/*
* 最小堆的向上調整算法(從start開始向上直到0，調整堆)
*
* 注：數組實現的堆中，第N個節點的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
*
* 參數說明：
*     start -- 被上調節點的起始位置(一般爲數組中最後一個元素的索引)
*/
static void filter_up(int start)
{
   int c = start;            // 當前節點(current)的位置
   int p = (c-1)/2;        // 父(parent)結點的位置 
   int tmp = m_heap[c];        // 當前節點(current)的大小

   while(c > 0)
   {
       if(m_heap[p] <= tmp)
           break;
       else
       {
           m_heap[c] = m_heap[p];
           c = p;
           p = (p-1)/2;   
       }       
   }
   m_heap[c] = tmp;
}
 
/* 
* 將data插入到二叉堆中
*
* 返回值：
*     0，表示成功
*    -1，表示失敗
*/
int minheap_insert(int data)
{
   // 如果"堆"已滿，則返回
   if(m_size == m_capacity)
       return -1;

   m_heap[m_size] = data;        // 將"數組"插在表尾
   filter_up(m_size);            // 向上調整堆
   m_size++;                    // 堆的實際容量+1

   return 0;
}
 
/* 
* 打印二叉堆
*
* 返回值：
*     0，表示成功
*    -1，表示失敗
*/
void minheap_print()
{
   int i;
   for (i=0; i<m_size; i++)
       printf("%d ", m_heap[i]);
}

void main()
{
   int a[] = {80, 40, 30, 60, 90, 70, 10, 50, 20};
   int i, len=LENGTH(a);

   printf("== 依次添加: ");
   for(i=0; i<len; i++)
   {
       printf("%d ", a[i]);
       minheap_insert(a[i]);
   }

   printf("\n== 最 小 堆: ");
   minheap_print();

   i=15;
   minheap_insert(i);
   printf("\n== 添加元素: %d", i);
   printf("\n== 最 小 堆: ");
   minheap_print();

   i=10;
   minheap_remove(i);
   printf("\n== 刪除元素: %d", i);
   printf("\n== 最 小 堆: ");
   minheap_print();
   printf("\n");
}

二叉堆的C測試程序

測試程序已經包含在相應的實現文件中了，這裏就不再重複說明了。

最大堆(max_heap.c)的運行結果：

== 依次添加: 10 40 30 60 90 70 20 50 80 
== 最 大 堆: 90 80 70 60 40 30 20 10 50 
== 添加元素: 85
== 最 大 堆: 90 85 70 60 80 30 20 10 50 40 
== 刪除元素: 90
== 最 大 堆: 85 80 70 60 40 30 20 10 50

最小堆(min_heap.c)的運行結果：

== 依次添加: 80 40 30 60 90 70 10 50 20 
== 最 小 堆: 10 20 30 50 90 70 40 80 60 
== 添加元素: 15
== 最 小 堆: 10 15 30 50 20 70 40 80 60 90 
== 刪除元素: 10
== 最 小 堆: 15 20 30 50 90 70 40 80 60

二叉堆(一)之圖文解析和 C語言的實現

概要

堆和二叉堆的介紹

二叉堆的圖文解析

二叉堆的C實現(完整源碼)

二叉堆的C測試程序

vue項目獲取富文本編輯器wangEditor內容導出爲word（html轉word格式並下載）

dotnet C# 創建 X11 應用時設置窗口背景顏色

Navicat安裝與激活教程

TDengine docker安裝方法

vue3組件通信與props

sapui5

Alpine Linux apk add DNS lookup error

部分JDK版本的發佈時間

工作中用到的腳本合集

合併代碼時Beyond Compare設置

位運算二進制大雜燴一勞永逸

最短路徑算法——Dijkstra,Bellman-Ford,Floyd-Warshall,Johnson，無一倖免

棧的圖文解析和對應3種語言的實現(C/C++/Java)

有向強連通和網絡流大講堂——史無前例最大流（最小割）、最小費用最大流

二叉堆(一)之圖文解析和 C語言的實現

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

二叉堆(一)之 圖文解析 和 C語言的實現

概要

堆和二叉堆的介紹

二叉堆的圖文解析

二叉堆的C實現(完整源碼)

二叉堆的C測試程序

二叉堆(一)之圖文解析和 C語言的實現