2. 程式人生 > >資料結構堆的實現以及堆的面試題

資料結構堆的實現以及堆的面試題

阿新 • • 發佈：2019-02-01

堆

堆的特點

堆有大堆和小堆之分

小堆：
①任意結點的關鍵碼均小於等於他的左右孩子的關鍵碼
②位於堆頂的結點的關鍵碼最小
③從根結點到每個結點的路徑上陣列元素組成的序列都是遞增的

大堆：
①任意結點的關鍵碼均大於等於他的左右孩子的關鍵碼
②位於堆頂的結點的關鍵碼最大
③從根結點到每個結點的路徑上陣列元素組成的序列都是遞減的

這裡寫圖片描述

堆儲存在下標為0的陣列中，因此在堆中給定下標為i的結點時有：
①如果i=0，結點i是根節點，沒有雙親節點；否則結點i的雙親結點為
結點(i-1)/2
②如果2 * i + 1 <= n - 1（n為堆中結點個數），則結點i的左孩子為結
點2 * i + 1，否則結點i無左孩子
③如果2 * i + 2 <= n - 1（同上），則結點i的右孩子為結點2 * i + 2，
否則結點i無右孩子

堆的實現

heap.h

#pragma once

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

typedef int HPDataType;
typedef int (*PCompare)(HPDataType left, HPDataType right);//函式指標，用小堆就選Less，用大堆就選Greater
typedef struct Heap
{
    HPDataType *_hp;
    int _size;//堆中的元素個數
    int _capacity;//堆的容量
 

    PCompare _com;
}Heap;

// 小於比較 
int Less(HPDataType left, HPDataType right);
// 大於比較 
int Greater(HPDataType left, HPDataType right);
// 初始化堆 
void InitHeap(Heap* hp);
// 建立堆 
void CreateHeap(Heap* hp, int* array, int size, PCompare com);
//檢查擴容
void _CheckCapacity(Heap* hp);
// 在堆中插入元素data 
void InsertHeap(Heap* hp, HPDataType data);
// 刪除堆頂的元素 
 

void RemoveHeap(Heap* hp);
// 獲取堆中有效元素個數 
int SizeHeap(Heap* hp);
// 檢測堆是否為空 
int EmptyHeap(Heap* hp);
// 獲取堆頂元素 
HPDataType TopHeap(Heap* hp);
// 銷燬堆 
void DestroyHeap(Heap* hp);
// 向下調整 
void AdjustDown(Heap* hp, int parent);
// 向上調整 
void AdjustUp(Heap* hp, int child);
heap.c


#include "heap.h"


int Less(HPDataType left, HPDataType right)
{
    return left < right;
}

int Greater(HPDataType left, HPDataType right)
{
    return left > right;
}

void InitHeap(Heap* hp)
{
    assert(hp);
    hp->_hp = (HPDataType*)malloc(3 * sizeof(HPDataType));//初始化開闢多少都行
    hp->_capacity = 3;
    hp->_size = 0;
}

void Swap(HPDataType *left, HPDataType*right)
{
    HPDataType tmp = 0;
    tmp = *left;
    *left = *right;
    *right = tmp;
}

void AdjustUp(Heap* hp, int child)
{
    assert(hp);
    int parent = (child - 1) / 2;//找出父母結點下標
    while (child)//只要child還為非零，就繼續迴圈
    {
        if (hp->_com(hp->_hp[child], hp->_hp[parent]))//是否需要父母結點
                                                      //與孩子結點交換關鍵碼
        {
            Swap(&hp->_hp[child], &hp->_hp[parent]);
            child = parent;//此時孩子結點上移到父母結點
            parent = (child - 1) / 2;//計算新的父母結點
        }
        else
            return;
    }
}

void AdjustDown(Heap* hp, int parent)
{
    assert(hp);
    if (NULL == hp)
        return;
    int child = parent * 2 + 1;//計算左孩子結點下標
    while (child < hp->_size)//只要孩子結點下標不越界
    {
        if (child + 1 < hp->_size&&hp->_com(hp->_hp[child+1],hp->_hp[child]))
        //是否需要左右孩子交換關鍵碼，我是以左孩子是否與父母交換關鍵碼為前提
        {
            Swap(&hp->_hp[child], &hp->_hp[child + 1]);
        }
        if (hp->_com(hp->_hp[child], hp->_hp[parent]))//是否左孩子與父母交換關鍵碼
        {
            Swap(&hp->_hp[child], &hp->_hp[parent]);
            parent = child;//父母結點移到孩子結點，當做下一個父母結點
            child = parent * 2 + 1;
        }
        else
            return;
    }
}

void CreateHeap(Heap* hp, int* array, int size, PCompare com)
{
    assert(hp);
    int root = (size - 2) / 2;//找到最後一個非葉子結點的結點
    int i = 0;
    hp->_hp = (HPDataType*)malloc(size * sizeof(HPDataType));
    if (hp == NULL)
        return;
    for (i = 0; i < size; i++)
    {
        hp->_hp[i] = array[i];
    }
    hp->_capacity = size;
    hp->_size = size;
    hp->_com = com;
    while (root>=0)//從當前結點一直向下調整到下標為零的結點
    {
        AdjustDown(hp,root);
        root--;
    }
}

void _CheckCapacity(Heap* hp)
{
    assert(hp);
    int i = 0;
    HPDataType *new = NULL;
    int newcapacity = hp->_capacity * 2;
    new = (HPDataType*)malloc(newcapacity * sizeof(HPDataType));
    if (new == NULL)
        return;
    for (i = 0; i < hp->_size; i++)
    {
        new[i] = hp->_hp[i];
    }
    free(hp->_hp);
    hp->_hp = new;
    hp->_capacity = newcapacity;
}

void InsertHeap(Heap* hp, HPDataType data)
{
    assert(hp);
    if (hp->_capacity == hp->_size)
        _CheckCapacity(hp);
    hp->_hp[hp->_size] = data;//一定要先插入後size++
    AdjustUp(hp, hp->_size);
    hp->_size++;
}

void RemoveHeap(Heap* hp)
{
    assert(hp);
    if (NULL == hp)
        return;
    hp->_hp[0] = hp->_hp[hp->_size - 1];
    hp->_size--;//一定要先size--，後向下調整，否則他會把刪除的結點也調整了
    AdjustDown(hp, 0);
}

int SizeHeap(Heap* hp)
{
    assert(hp);
    return hp->_size;
}

int EmptyHeap(Heap* hp)
{
    assert(hp);
    return 0 == hp->_size;
}

HPDataType TopHeap(Heap* hp)
{
    assert(hp);
    return hp->_hp[0];
}

void DestroyHeap(Heap* hp)
{
    assert(hp);
    if (hp)
    {
        free(hp);
        hp->_capacity = 0;
        hp->_size = 0;
    }
}

優先順序佇列

heap.h


typedef struct PriorityQueue
{
    Heap hp;
}PriorityQueue;

//初始化
void InitPriorityQueue(PriorityQueue* q);

//入佇列
void PushPriorityQueue(PriorityQueue* q, HPDataType data);

//出佇列
void PopPriorityQueue(PriorityQueue* q);

//取隊頭元素
void TopPriorityQueue(PriorityQueue* q);

//佇列長度
int SizePriorityQueue(PriorityQueue* q);

//判空
int EmptyPriorityQueue(PriorityQueue* q);
heap.c


void InitPriorityQueue(PriorityQueue* q)
{
    InitHeap(&q->hp);
}

void PushPriorityQueue(PriorityQueue* q, HPDataType data)
{
    InsertHeap(&q->hp, data);
}

void PopPriorityQueue(PriorityQueue* q)
{
    RemoveHeap(&q->hp);
}

void TopPriorityQueue(PriorityQueue* q)
{
    return TopHeap(&q->hp);
}

int SizePriorityQueue(PriorityQueue* q)
{
    return SizeHeap(&q->hp);
}

int EmptyPriorityQueue(PriorityQueue* q)
{
    return EmptyHeap(&q->hp);
}

堆排序（降序，用小堆）

堆排序的原理：
①將堆頂元素和堆中最後一個元素交換
②此時陣列最後一個元素已經排好序了，因此將堆中元素減少一個
③此時堆結構可能被破壞，再向下調整使其滿足堆的性質
④將以上三個步驟迴圈起來，直到排序完陣列中的所有元素

void _AdjustDown(int *array, int size, int parent)
{
    int child = parent * 2 + 1;
    while (child < size)
    {
        if (child + 1 < size&&array[child + 1] < array[child])
        {
            Swap(&array[child + 1], &array[child]);
        }
        if (array[parent] > array[child])
        {
            Swap(&array[parent], &array[child]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
            return;
    }
}
void MakeHeap(int *array, int size)
{
    int root = (size - 2) / 2;
    while (root >= 0)
    {
        _AdjustDown(array,size, root);
        root--;
    }
}

void HeapSort(int *array, int size)
{
    MakeHeap(array, size);//把傳過來的陣列建立成堆
    while (size)//調整完所有元素
    {
        Swap(&array[0], &array[size - 1]);//交換堆頂元素和堆中最後一個元素
        size--;//減少堆中元素一個
        _AdjustDown(array, size, 0);//向下調整
    }
}

測試

test.c


#include "heap.h"
int main()
{
    //Heap hp;//被註釋了的是測試堆的實現的程式碼，沒被註釋的是測試堆排序的程式碼，優先順序佇列大家就自己測試吧
    int i = 0;
    int array[] = { 53,17,78,9,45,65,87,23,31 };
    //InitHeap(&hp);
    //CreateHeap(&hp, array, sizeof(array)/sizeof(array[0]), Less);
    //for (i = 0; i < hp._size; i++)
    //{
    //  printf("%d ", hp._hp[i]);
    //}
    //printf("\n");
    //printf("%d ", TopHeap(&hp));
    //printf("%d ", SizeHeap(&hp));
    //printf("\n");
    int size = sizeof(array) / sizeof(array[0]);
    HeapSort(array,size);
    for (i = 0; i < size; i++)
    {
        printf("%d ", array[i]);
    }
    printf("\n");
    //InsertHeap(&hp,11);
    //for (i = 0; i < hp._size; i++)
    //{
    //  printf("%d ", hp._hp[i]);
    //}
    //printf("\n");
    //printf("%d ", TopHeap(&hp));
    //printf("%d ", SizeHeap(&hp));
    //printf("\n");
    //RemoveHeap(&hp);
    //for (i = 0; i < hp._size; i++)
    //{
    //  printf("%d ", hp._hp[i]);
    //}
    //printf("\n");
    //printf("%d ", TopHeap(&hp));
    //printf("%d ", SizeHeap(&hp));
    system("pause");
    return 0;
}

相關推薦

【資料結構】---------二叉樹面試題（具體的所有實現）

實現二叉樹的相關的操作： 先序遍歷樹（遞迴） 中序遍歷樹（遞迴） 後序遍歷樹（遞迴） 層序遍歷樹 建立一棵樹 樹的銷燬 樹的拷貝 二叉樹中節點的個數 二叉樹葉子節點的個數 二叉樹第K層節點的個數 樹的高度 在二叉樹中查詢節點 找當前節點的左子樹

資料結構與演算法-----常問面試題

資料結構 陣列 尋找陣列中第二小的元素 找到陣列中第一個不重複出現的整數 合併兩個有序陣列 重新排列陣列中的正值和負值 棧 使用棧計算字尾表示式 對棧的元素進行排序 判斷表示式是否括號平衡 佇列 使用隊列表示棧 對佇列的前k個元素倒序 使用佇列生成從1到n

資料結構--棧和佇列的面試題

實現一個棧，要求實現Push(出棧)、Pop(入棧)、Min(返回最小值)的時間 複雜度為O(1) 方法1、棧Push時：當棧為空時，push兩次第一個資料。棧頂的數來儲存當前狀態的最小值。 再次Push資料時候，先拿將要Push的資料與棧頂的最小值進行比較，更

【資料結構】二叉樹面試題總結

為了對二叉樹的知識進行鞏固，今天我們來解析5道二叉樹的經典面試題。 這五道面試題如下： 求二叉樹中最遠兩個結點的距離； 判斷一棵樹是否是完全二叉樹； 由前序和中序遍歷序列重建二叉樹 （前序序列：1 2 3 4 5 6 - 中序序列:3 2 4 1 6

資料結構堆的實現以及堆的面試題

堆 堆的特點 堆有大堆和小堆之分 小堆： ①任意結點的關鍵碼均小於等於他的左右孩子的關鍵碼 ②位於堆頂的結點的關鍵碼最小 ③從根結點到每個結點的路徑上陣列元素組成的序列都是遞增的 大堆： ①任意結點的關鍵碼均大於等於他的左右孩子的關鍵碼

【資料結構】之用堆實現優先佇列

#include <stdio.h> #include <malloc.h> /** * 使用堆來實現優先佇列 * 堆的最重要性質就是子節點的值>=父節點的值, *

純資料結構Java實現(6/11)(二叉堆&優先佇列)

堆其實也是樹結構(或者說基於樹結構)，一般可以用堆實現優先佇列。 二叉堆 堆可以用於實現其他高層資料結構，比如優先佇列 而要實現一個堆，可以藉助二叉樹，其實現稱為: 二叉堆 (使用二叉樹表示的堆)。 但是二叉堆，需要滿足一些特殊性質: 其一、二叉堆一定是一棵完全二叉樹 (完全二叉樹可以用陣列表示，見下面)

資料結構之二叉堆

  什麼是二叉堆？ 二叉堆 本質上就是一顆 二叉樹 ，而根據根節點資料的不同又分為：最大堆 和 最小堆。 什麼是最大堆？父節點的值 永遠 大於等於 兩個 孩子節點 的值。     &n

資料結構：樹&堆的概念：持續編輯中

樹---|---：由 一個根結點 和 N個子結點 及 連線線 構成，任意結點間不構成迴路        |---二叉樹---|---：樹的一種，且任意結點最多隻能有兩個子結點        |     &n

常見資料結構(一)-棧,佇列,堆,雜湊表

轉載：https://blog.csdn.net/u013063153/article/details/54667361?locationNum=8&fps=1 寫在前面 本文所有圖片均截圖自coursera上普林斯頓的課程《A

（Java資料結構和演算法）堆---優先佇列、堆排序

堆主要用於實現優先佇列。 利用有序陣列可以實現優先佇列（從小到大或從大到小的陣列），刪除的時間複雜度是O(1)，但是插入的時間複雜度是O(N)。用堆實現優先佇列，插入和刪除的時間複雜度都是O(logN)。 簡介 堆是一種完全二叉樹，且每個節點的值都大於等於子節點值（大根堆）。

排序演算法之堆排序（關鍵詞：資料結構/演算法/排序演算法/堆排序）

假定：有 1 個亂序的數列 nums ，其中有 n 個數。 要求：排好序之後是 從小到大 的順序。 堆排序演算法 原理 先將原始的堆，調整為最大堆： 從倒數第 1 個有子結點的結點(下標為 index = n//2 - 1)開始，將以結點 index 為根結點的子堆

資料結構和記憶體中堆和棧的區別

特別宣告：本文參考了部落格：http://blog.csdn.net/wolenski/article/details/7951961#comments        堆和棧在 我的眼裡一直是很模糊的概念，只是簡單的理解為：堆疊是一種資料結構，是用來儲存資料的。由於最近

Ted 帶你學習資料結構 之 二叉堆（Binary Heap）

二叉堆（Binary Heap） （1）structure property Heap（堆）是一個除了底層節點外的完全填滿的二叉樹，底層可以不完全，左到右填充節點。（a heap is a binar

8皇后以及N皇后演算法探究，回溯演算法的JAVA實現，非遞迴，資料結構“棧”實現

是使用遞迴方法實現回溯演算法的，在第一次使用二維矩陣的情況下，又做了一次改一維的優化 但是演算法效率仍然差強人意，因為使用遞迴函式的緣故 下面提供另一種回溯演算法的實現，使用資料結構”棧“來模擬，遞迴函式的手工實現，因為我們知道計算機在處理遞迴時的本質就是棧 時間複雜度是一樣的，空間

資料結構——優先佇列與堆

什麼是優先佇列？ 普通佇列:先進先出，後進後出 優先佇列:出隊順序和入隊順序無關；和優先順序相關，如醫院中，病重先安排病床 優先佇列的現例項子： ①cpu任務排程，動態選擇優先順序最高的任務執行 ②王者榮耀中，攻擊鍵優先打敵人，無敵人時候優先打最近的小兵 關於

資料結構——優先佇列和堆

優先佇列： 優先佇列也是一個佇列，他和普通佇列的區別是：普通佇列是先進先出，後進先出的；優先佇列是出隊順序和入隊順序無關，和優先順序相關。（如：醫院看病時，病情最嚴重的那個需要先看病）  實現優先佇列同樣底層也可以選擇多種資料結構， 選擇 普通的線性結構實現：出隊O(1),入隊

Unity實戰篇：實現連連看死局判定（一：資料結構的選擇以及基本思路概述）

最近在做連連看小遊戲，整體完成的差不多，還差一個死局判定，若為死局，即重新洗牌。 由於專案結構較為繁雜，建議大家先下載原始碼 原始碼下載連結：https://gitee.com/NKG/UnityWorks/blob/master/UnityPackages/LinkUp.unitypa

【資料結構】實現順序表以及簡單的時間複雜度分析

最近在學資料結構，接下來一段時間我將用java來實現所學的各種資料結構，以加深自己的印象。 線性表包括順序表和連結串列，其實順序表就是動態陣列，下面我將二次封裝實現屬於自己的動態陣列。 -------------------------------------------

最小生成樹（二）--prim演算法實現以及堆優化

一、最小生成樹---prim演算法實現 思想： 1、從任意一個頂點開始構造生成樹，假設就從1號頂點吧， 首先將頂點1加入生成樹中，用一個一維陣列book來標記 哪些頂點已經加入了生成樹。  2、用陣列dis記錄生成樹到各個頂點的距離，最初生成樹中之後1號 頂點，有直連邊時，