2. 程式人生 > >資料結構--二叉堆與堆排序

資料結構--二叉堆與堆排序

阿新 • • 發佈：2019-01-23
  • 二叉堆的概念

二叉堆，BinaryHeap，是二叉樹中的常見的一種結構。通常以最大堆和最小堆的形式呈現。最大堆指的是父節點大於等於孩子節點的value值，也就是說對於最大堆而言，根元素是二叉堆最大的元素。最小堆的概念是與最大堆的概念是相似的。下圖是最大堆的示意圖：

  • 二叉堆和排序之間的聯絡

二叉堆最顯著的特徵就是根元素是二叉樹元素間最大的或者最小的。因此每次將二叉樹最大或者最小的元素取出來，同時保證每次進行這樣的操作後，剩下的元素依然可以保持二叉堆的性質，這樣迭代這個過程，就可以完成排序的目的。

所以，進行堆排序的過程，首先就需要進行待排序元素的堆建立過程。這裡以最大堆為例。

堆的建立過程

在建立最大堆的過程中，每插入一個元素，就要對元素進行一個上浮的操作。上浮是指對每個即將插入最大堆的元素進行判斷，判斷與當前元素與其父元素的大小關係，保持父元素與孩子元素之間的大小關係，重複這個過程，直到從根元素開始，所有的父元素和孩子元素都和二叉堆的定義保持一致。具體實現過程如下：

首先是最大堆的ADT:

template<class T>
class BinaryHeap
{
public:
    BinaryHeap(int capacity);
    ~BinaryHeap();

    void filterUp(int start);
    void Insert(T &data);


    T delHeap();

    void BuildHeap(vector<T> initArray);
    void displayHeap();

private:
    T *m_pData;
    int mCurSize;
    int mCapacity;
};
然後是最大堆的建立過程： 
template<class T>
void BinaryHeap<T>::filterUp(int start)
{

    int nIndex=start;
    T temp=m_pData[nIndex];
    int parentIndex=(int) start/2;

    while(nIndex>0)
    {
        if(m_pData[parentIndex]<temp)
        {
            m_pData[nIndex]=m_pData[parentIndex];
            nIndex=parentIndex;
            parentIndex=(int) nIndex/2;
        }
        else
            break;
    }
    m_pData[nIndex]=temp;

}

template<class T>
void BinaryHeap<T>::Insert(T &data)
{
    if(mCurSize>=mCapacity)
    {
        mCapacity*=2;
        mCurSize++;
    }
    m_pData[mCurSize]=data;
    filterUp(mCurSize);
}

完成了最大堆的建立，就可以進行最大元素的抽取了，將抽取的元素存起來，就可以進行迭代過程的排序了：

這裡在抽取最大元素的抽取後，相應的元素個數就會減少一個，如果是把根元素的孩子結點移動到根元素的位置，然後從上往下進行這樣的移動，這樣不能很好的保持完全二叉樹的性質。因此這裡採取的小技巧是，將二叉樹的最後一個元素移動到根元素的位置，這樣僅僅只是交換value值，不需要頻繁的移動元素的位置。以下是該過程的示意圖：

第一步：



第二步：



這樣就完成了最大元素的抽取過程了，然後下面是具體的實現過程：

template<class T>
T BinaryHeap<T>::delHeap()
{
    int parentIndex=0;
    T tempMax=m_pData[parentIndex];
    int nIndex=parentIndex*2+1;

    m_pData[parentIndex]=m_pData[mCurSize-1];
    T tempCur=m_pData[parentIndex];
    while((nIndex+1)<mCurSize)
    {

        if(tempCur>=m_pData[nIndex] && tempCur>=m_pData[nIndex+1])
        {

            break;
        }
        else
        {
            if(m_pData[nIndex]>m_pData[nIndex+1])
                {
                    m_pData[parentIndex]=m_pData[nIndex];
                    parentIndex=nIndex;
                }
            else
                {
                     m_pData[parentIndex]=m_pData[nIndex+1];
                     parentIndex=nIndex+1;
                }

                     nIndex=2*parentIndex+1;
        }
    }
    m_pData[parentIndex]=tempCur;
    if(mCurSize>1)
        mCurSize--;
    else
    {
        mCurSize--;
        cout<<"the heap size is zero!"<<endl;
    }
    return tempMax;

}

以上就是關鍵的過程的程式碼，下面是完整過程的程式碼：

首先是二叉堆的標頭檔案：

#ifndef BINARYHEAP_H_INCLUDED
#define BINARYHEAP_H_INCLUDED

#include<vector>
#include<queue>
#include<iostream>
using namespace std;
template<class T>
class BinaryHeap
{
public:
    BinaryHeap(int capacity);
    ~BinaryHeap();

    void filterUp(int start);
    void Insert(T &data);


    T delHeap();

    void BuildHeap(vector<T> initArray);
    void displayHeap();

private:
    T *m_pData;
    int mCurSize;
    int mCapacity;
};


template<class T>
BinaryHeap<T>::BinaryHeap(int capacity)
{
    mCurSize=0;
    mCapacity=capacity;
    m_pData=new T[capacity];
}

template<class T>
BinaryHeap<T>::~BinaryHeap()
{
    mCurSize=0;
    mCapacity=0;
    delete []m_pData;
}

template<class T>
void BinaryHeap<T>::filterUp(int start)
{

    int nIndex=start;
    T temp=m_pData[nIndex];
    int parentIndex=(int) start/2;

    while(nIndex>0)
    {
        if(m_pData[parentIndex]<temp)
        {
            m_pData[nIndex]=m_pData[parentIndex];
            nIndex=parentIndex;
            parentIndex=(int) nIndex/2;
        }
        else
            break;
    }
    m_pData[nIndex]=temp;

}

template<class T>
void BinaryHeap<T>::Insert(T &data)
{
    if(mCurSize>=mCapacity)
    {
        mCapacity*=2;
        mCurSize++;
    }
    m_pData[mCurSize]=data;
    filterUp(mCurSize);
}

template<class T>
void BinaryHeap<T>::BuildHeap(vector<T> initArray)
{
    int nSize=initArray.size();
    if(nSize==0)
        return;
    else
    {
        for(int i=0;i<nSize;i++)
        {
            Insert(initArray.at(i));
            if(mCurSize<mCapacity)
                mCurSize++;
            else
            {
                mCapacity*=2;
                mCurSize++;
            }
        }

    }
}

template<class T>
T BinaryHeap<T>::delHeap()
{
    int parentIndex=0;
    T tempMax=m_pData[parentIndex];
    int nIndex=parentIndex*2+1;

    m_pData[parentIndex]=m_pData[mCurSize-1];
    T tempCur=m_pData[parentIndex];
    while((nIndex+1)<mCurSize)
    {

        if(tempCur>=m_pData[nIndex] && tempCur>=m_pData[nIndex+1])
        {

            break;
        }
        else
        {
            if(m_pData[nIndex]>m_pData[nIndex+1])
                {
                    m_pData[parentIndex]=m_pData[nIndex];
                    parentIndex=nIndex;
                }
            else
                {
                     m_pData[parentIndex]=m_pData[nIndex+1];
                     parentIndex=nIndex+1;
                }

                     nIndex=2*parentIndex+1;
        }
    }
    m_pData[parentIndex]=tempCur;
    if(mCurSize>1)
        mCurSize--;
    else
    {
        mCurSize--;
        cout<<"the heap size is zero!"<<endl;
    }
    return tempMax;

}

template<class T>
void BinaryHeap<T>::displayHeap()
{
    for(int i=0;i<mCurSize;i++)
    {
        cout<<m_pData[i]<<"---";
    }
    cout<<endl;
}



#endif // BINARYHEAP_H_INCLUDED
然後是主過程的呼叫，在主過程完成排序： 
#include <iostream>
#include<cstdlib>
#include<ctime>
#include"BinaryHeap.h"

using namespace std;

int main()
{
    srand(unsigned(time(NULL)));

    vector<int> initArray;
    int data=rand()%100;
    int length=rand()%15;
    int cnt=0;
    while(cnt<length)
    {
        initArray.push_back(data);
        data=rand()%100;
        cnt++;
    }

    cout<<"待排序序列："<<endl;
    for(int i=0;i<length;i++)
        cout<<initArray.at(i)<<"---";
    cout<<endl;

    BinaryHeap<int> heap(30);
    heap.BuildHeap(initArray);
    cout<<"建立好的最大堆："<<endl;
    heap.displayHeap();

    int maxEle;
    vector<int> sortedArray;
    for(int i=0;i<initArray.size();i++)
    {
        maxEle=heap.delHeap();
        sortedArray.push_back(maxEle);

    }

    cout<<"排序完成的序列："<<endl;
    for(int i=0;i<sortedArray.size();i++)
    {
        cout<<sortedArray.at(i)<<"---";
    }
        cout<<endl;
    cout << "Hello world!" << endl;
    return 0;
}
然後結果如下：




相關推薦

資料結構--二叉堆與堆排序

二叉堆的概念 二叉堆，BinaryHeap，是二叉樹中的常見的一種結構。通常以最大堆和最小堆的形式呈現。最大堆指的是父節點大於等於孩子節點的value值，也就是說對於最大堆而言，根元素是二叉堆最大的元素。最小堆的概念是與最大堆的概念是相似的。下圖是最大堆的示意圖： 二

淺談演算法和資料結構: 五 優先順序佇列與堆排序

在很多應用中，我們通常需要按照優先順序情況對待處理物件進行處理，比如首先處理優先順序最高的物件，然後處理次高的物件。最簡單的一個例子就是，在手機上玩遊戲的時候，如果有來電，那麼系統應該優先處理打進來的電話。 在這種情況下，我們的資料結構應該提供兩個最基本的操作，一個是返回最高優先

Python資料結構——二叉堆的實現

優先佇列的二叉堆實現 在前面的章節裡我們學習了“先進先出”（FIFO）的資料結構：佇列（Queue）。佇列有一種變體叫做“優先佇列”（Priority Queue）。優先佇列的出隊（Dequeue）操作和佇列一樣，都是從隊首出隊。但在優先佇列的內部，元素的次序卻是由“優先順序”來決定：高優先順序

資料結構 9 基礎資料結構 二叉堆 瞭解二叉堆的元素插入、刪除、構建二叉堆的程式碼方式

是否記得我們在之前的學習中有學習到`二叉樹` 忘記的小夥伴們請檢視：完全二叉樹的定義。 > https://blogs.chaobei.xyz/archives/shuju2 ## 二叉堆 二叉堆其實就是一個`完全二叉樹` 一起復習一下吧：關於二叉樹和滿二叉樹以及完全二叉樹的基本概念。 ### 二叉樹

Python資料結構——二叉樹排序

二叉排序樹的過程主要是：二叉樹的構建和遍歷。 當樹構建好後，對樹進行中序遍歷（左中右），即可得到，對資料從小到大排序的結果。 如果對樹進行“右中左遍歷”，則可以得到，對資料從大到小排序的結果 # -*- coding:utf-8 -*- # file: pySort.py #

資料結構——二叉樹的建立與遞迴遍歷

#include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct Node{ //二叉樹的鏈式儲存結點 char data; struct Node *Lch

資料結構——二叉排序樹

建立、查詢、刪除 codeblocks 17 通過 #include <iostream> #define KeyType int #define InfoType char using namespace std; typedef struct { KeyType k

資料結構----二叉排序樹

結點結構 /**********結點結構*********/ typedef struct BTNode { int key; struct BTNode *lchild; struct BTN

演算法與資料結構二叉樹的一些理解

樹：有一個根節點，葉子節點可以有無數個。 森林：由多個樹組成的叫森林。 二叉樹：有一個根節點，只有左右葉子節點。 二叉排序樹：左葉子節點小於根節點，有葉子節點大於根節點。 滿二叉樹：最後一層的所有葉子節點都在，其葉子節點個數為2^(k-1)。 完全二叉樹：所有的左葉子節點都在。

簡述資料結構：棧記憶體與堆記憶體的儲存方式 js中的原始值

在討論堆疊前，先要明確什麼是原始值、引用值。 1.變數可以存放兩種型別的值： 原始值 和 引用值 2.原始值代表原始資料型別的值，也叫基本資料型別，包括 Number、Stirng、Boolean、Null、Underfined。 3.引用值指的是複合資料型別的

資料結構——二叉樹的遞迴與非遞迴遍歷（先序，中序，後序）

實驗專案五 二叉樹基本操作的實現 課程名稱：資料結構 實驗專案名稱：二叉樹基本操作的實現 實驗目的： 1．掌握樹的基本操作—遍歷。 實驗要求： 1、 分別用遞迴和非遞迴的方法實現一棵樹的三種遍歷。 實驗過程： 建立一棵二叉樹（二叉樹如下圖所示）；

資料結構——二叉樹的結點插入與遍歷

BTree.h: #ifndef _BTREE_H_ #define _BTREE_H_ //二叉樹的結點資料型別 typedef struct _btreeNode {     int data;     struct _btreeN

資料結構 二叉排序樹 操作及實現

#include<iostream> #include<cstdio> #include<cstdlib> #include<cstring> using namespace std; typedef struct Bitn

面試複習-------演算法與資料結構------二叉樹

建立二叉樹 （1）二叉樹的反序列化 給定“6423####51##7##”（先序）這種序列，構造二叉樹（假設只出現0~9數字，如果要擴充套件可以加空格） TreeNode* preOrderToTr

python演算法與資料結構-二叉樹的程式碼實現(46)

一、二叉樹回憶 　　上一篇我們對資料結構中常用的樹做了介紹，本篇部落格主要以二叉樹為例，講解一下樹的資料結構和程式碼實現。回顧二叉樹：二叉樹是每個節點最多有兩個子樹的樹結構。通常子樹被稱作“左子樹”（left subtree）和“右子樹”（right subt

什麼是泛型?,Set集合,TreeSet集合自然排序和比較器排序,資料結構-二叉樹,資料結構-平衡二叉樹

　　　　　　　　　　　　　　　　　　　　　　　　　　==知識點== 1.泛型 2.Set集合 3.TreeSet 4.資料結構-二叉樹 5.資料結構-平衡二叉樹 　　　　　　　　　　　　　　　　　　　　　　　　　　==用到的單詞== 1.element[ˈelɪmənt] 要素 元素（軟) 2.key[kiː

淺談資料結構-二叉樹

二叉樹是樹的特殊一種，具有如下特點：1、每個結點最多有兩顆子樹，結點的度最大為2。2、左子樹和右子樹是有順序的，次序不能顛倒。3、即使某結點只有一個子樹，也要區分左右子樹。 一、特殊的二叉樹及特點   1、斜樹 所有的結點都只有左子樹（左斜樹），或者只有右子樹（右斜樹）。這就是斜樹，應用較少

資料結構——二叉樹（程式碼）

 二叉樹 C++ 環境codeblocks17 通過 /* 二叉樹 使用了自定義的 棧 和 佇列 @CGQ 2018/10/29 */ #include <iostream> #include <stdio.h> #include <stdlib.h&

資料結構 二叉樹《c++版》

二叉樹節點BinNode模板類 #define BinNodePosi(T) BinNode<T> * //節點位置 #define stature(p) ((p) ? (p)->height : -1) //節點高度（與“空樹高度為-1”的約定相統一） typedef enu

二叉樹----資料結構:二叉樹的三種遍歷,利用遞迴演算法。

二叉樹----資料結構:二叉樹的三種遍歷,利用遞迴演算法。     魯迅:總之歲月漫長,然而值得等待。   #define CHAR /* 字元型 */  /* #define INT /* 整型（二者選一） */  #