堆

于 2018-05-17 12:46:37 发布
阅读量161 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alsnoa/article/details/80349232
版权

heap.h

// 1. 堆是一个完全二叉树 

// 2. 堆有两种, 一种叫小堆(小根堆, 最小堆), 

// 一种叫大堆(大根堆, 最大堆). 

// 3. 以小堆为例, 这个树的根节点是这个树中的最小的元素 

// 对于任意一个子树来说, 子树的根节点, 小于左右孩子节点的值. 

// 4. 以大堆为例, 这个树的根节点是这个树中的最大元素 

// 对于任意一个子树来说, 子树的根节点, 大于左右孩子节点的值. 



#pragma once 



#include<stddef.h> 



#define HeapMaxSize 1000 

typedef char HeapType; 



typedef int (*Compare)(HeapType a, HeapType b); 



typedef struct Heap { 

HeapType data[HeapMaxSize]; 

size_t size; 

Compare cmp; 

} Heap; 



void HeapInit(Heap* heap, Compare compare); 



void HeapInsert(Heap* heap, HeapType value); 



// 取堆顶元素 

int HeapRoot(Heap* heap, HeapType* value); 



// 删除堆顶元素 

void HeapErase(Heap* heap); 



int HeapEmpty(Heap* heap); 



size_t HeapSize(Heap* heap); 



void HeapDestroy(Heap* heap); 



// 在我们不想开辟额外的空间, 或者消耗额外的时间的前提下, 

// 如果我们想进行从小到大排序, 就需要一个大堆 

// 如果我们想进行从大到小排序, 就需要一个小堆 

void HeapSort(HeapType array[], size_t size);

heap.c

#include<stdio.h> 

#include<stdlib.h>

#include<string.h>

#include"heap.h"

#define HeapMaxSize 1000 

#define TEST_HEADER printf("\n===============%s===============\n",__FUNCTION__)





int Greater(HeapType a,HeapType b)

{

   return a>b ?1:0;

}



int Less(HeapType a,HeapType b)

{

    return a<b? 1:0;

}



void HeapInit(Heap* heap, Compare compare)

{

   if(heap==NULL)

   {

       return;

   }

   heap->size=0;

   heap->cmp=compare;





}



void HeapDestroy(Heap* heap)

{

  if(heap==NULL)

  {

      return;

  }

  heap->size=0;

  heap->cmp=NULL;

}



void Swap_data(HeapType* a,HeapType* b)

{

    HeapType  tmp =*a;

    *a=*b;

    *b=tmp;

    return;

}

void Adjustup(Heap* heap)

{

 int child=heap->size-1;

 int parent=(child-1)/2;

  while(child>0)

  {

     if(!heap->cmp(heap->data[parent],heap->data[child]))

     {

         Swap_data(&heap->data[parent],&heap->data[child]);

     }

     else

     {

         return;

     }

     child=parent;

     parent=(parent-1)/2;

   

  }

  

}



void HeapInsert(Heap* heap, HeapType value)

{

      if(heap==NULL)

      {

          return;

      }

      if(heap->size>=HeapMaxSize)

      {

        printf("The heap is full!");

        return;

      }



      heap->data[heap->size++]=value;

    Adjustup(heap);

}



// 取堆顶元素 

int HeapRoot(Heap* heap, HeapType* value)

{

  if(heap==NULL)

  {

      return 0;

  }

   if(heap->size==0)

   {

       return 0;

   }

   *value=heap->data[0];

   return 1;

}





void Adjustdown(Heap* heap)

{

    int parent=0;

    int child=2*parent +1;

while(child < (int)heap->size)

{

    if( child+1 < (int)heap->size)

    {

        if(!heap->cmp(heap->data[child],heap->data[child+1]))

        {

             ++child;

        }

    }

   if(!heap->cmp(heap->data[parent],heap->data[child]))

   {

      Swap_data(&heap->data[parent],&heap->data[child]);

   }

   else

   {

       return;

   }

    parent=child;

    child=2*child+1;



}



}

// 删除堆顶元素 

void HeapErase(Heap* heap)

{

    if(heap==NULL)

    {

        return;

    }

    if(heap->size==0)

    {

        return;

    }

    if(heap->size==1)

    {

        --heap->size;

        return;

    }

    Swap_data(&heap->data[0],&heap->data[heap->size-1]);

     --heap->size;

  Adjustdown(heap);

}





int HeapEmpty(Heap* heap)

{

    if(heap==NULL)

    {

        return 0;

    }

    if(heap->size==0)

    {

        return 0;

    }

    return 1;

}





size_t HeapSize(Heap* heap)

{

   if(heap==NULL)

   {

       return 0;

   }

   return heap->size;



}



void printall(Heap* heap)

{

    int i=0;

    for(i=0;i<6;i++)

    {



    printf("%c",heap->data[i]);

    }

printf("\n");

}



 void HeapPrint(Heap* heap,const char* str)

{

   printf("\n----------%s---------\n",str);

   int i=0;

   printf("heap data:");

   while(i < (int)heap->size)

   {

   printf("%c",heap->data[i]);

   i++;

   }

   printf("\n");

   printf("heap size:%lu\n",heap->size);

   printf("heap cmp: Greater \n");

   printf("\n");

   printall(heap);

}

// 在我们不想开辟额外的空间, 或者消耗额外的时间的前提下, 

// 如果我们想进行从小到大排序, 就需要一个大堆 

// 如果我们想进行从大到小排序, 就需要一个小堆 

void HeapSort(HeapType array[], size_t size)

{

   Heap heap;

   HeapInit(&heap,Greater);

   size_t i=0;

   while(i<size)

   {

       HeapInsert(&heap,array[i]);

       i++;

   }

   HeapPrint(&heap,"Insert six value");

   while(heap.size>0)

   {

      HeapErase(&heap);

   }



      HeapPrint(&heap,"Erease six value");

      memmove(array,&heap.data,size);

   

}

void Testinit()

{

   TEST_HEADER;

   Heap heap;

   HeapInit(&heap,Greater);

   HeapPrint(&heap,"Init heap!");

}



void TestInsert()

{

  TEST_HEADER;

  Heap heap;

  HeapInit(&heap,Greater);

  HeapInsert(&heap,'e');

  HeapInsert(&heap,'c');

  HeapInsert(&heap,'d');

  HeapInsert(&heap,'a');

  HeapInsert(&heap,'f');

  HeapInsert(&heap,'b');

  HeapPrint(&heap,"insert heap");

}



void TestRoot()

{

  TEST_HEADER;

  Heap heap;

  HeapType value;

  HeapInit(&heap,Greater);

  HeapInsert(&heap,'e');

  HeapInsert(&heap,'c');

  HeapInsert(&heap,'d');

  HeapInsert(&heap,'a');

  HeapInsert(&heap,'f');

  HeapRoot(&heap,&value);

  HeapPrint(&heap,"heap top expect f");

  printf("value :%c \n",value); 

}



void TestErease()

{



  TEST_HEADER;

  Heap heap;

  HeapInit(&heap,Greater);

  HeapInsert(&heap,'e');

  HeapInsert(&heap,'c');

  HeapInsert(&heap,'d');

  HeapInsert(&heap,'a');

  HeapInsert(&heap,'f');

  HeapInsert(&heap,'b');

  HeapPrint(&heap,"insert heap six value");

  HeapErase(&heap);

  HeapPrint(&heap,"Erease heap one value");

  HeapErase(&heap);

  HeapPrint(&heap,"Erease heap two value");

  HeapErase(&heap);

  HeapPrint(&heap,"Erease heap three value");

  HeapErase(&heap);

  HeapPrint(&heap,"Erease heap four value");

  HeapErase(&heap);

  HeapPrint(&heap,"Erease heap five value");

  HeapErase(&heap);

  HeapPrint(&heap,"Erease heap six  value");

}



void TestHeapsort()

{

    TEST_HEADER;

    HeapType arr[]={'e','c','d','a','f','b'};

    int size=sizeof(arr)/sizeof(arr[0]);

    HeapSort(arr,size);



    int i=0;

    while(i<size)

    {

    printf("%c",arr[i]);

    i++;

    }

     printf("\n");

}

int main()

{

   Testinit();

   TestInsert();

   TestRoot();

   TestErease();

   TestHeapsort();

   return 0;

}

运行结果

===============Testinit===============


----------Init heap!---------
heap data:
heap size:0
heap cmp: Greater 


0<y�


===============TestInsert===============


----------insert heap---------
heap data:fedacb
heap size:6
heap cmp: Greater 


fedacb


===============TestRoot===============


----------heap top expect f---------
heap data:fedac
heap size:5
heap cmp: Greater 


fedacb
value :f 


===============TestErease===============


----------insert heap six value---------
heap data:fedacb
heap size:6
heap cmp: Greater 


fedacb


----------Erease heap one value---------
heap data:ecdab
heap size:5
heap cmp: Greater 


ecdabf


----------Erease heap two value---------
heap data:dcba
heap size:4
heap cmp: Greater 


dcbaef


----------Erease heap three value---------
heap data:cab
heap size:3
heap cmp: Greater 


cabdef


----------Erease heap four value---------
heap data:ba
heap size:2
heap cmp: Greater 


bacdef


----------Erease heap five value---------
heap data:a
heap size:1
heap cmp: Greater 


abcdef


----------Erease heap six  value---------
heap data:
heap size:0
heap cmp: Greater 


abcdef


===============TestHeapsort===============


----------Insert six value---------
heap data:fedacb
heap size:6
heap cmp: Greater 


fedacb


----------Erease six value---------
heap data:
heap size:0
heap cmp: Greater 


abcdef
abcdef

Alsnoa
关注
专栏目录
堆排序详细图解（通俗易懂）
oorik的博客
02-17 24万+
什么是堆 堆是一种叫做完全二叉树的数据结构，可以分为大根堆，小根堆，而堆排序就是基于这种结构而产生的一种程序算法。 堆的分类 大根堆:每个节点的值都大于或者等于他的左右孩子节点的值 小根堆:每个结点的值都小于或等于其左孩子和右孩子结点的值 两种结构映射到数组为: 大根堆: 小根堆: //父-->子:i--->左孩子:2*i+1, 右孩子:2*i+2; //子-->父:i--->(i-1)*2;(i为下标元素) 排序思想 1.首先将待排序的数...
数据结构——堆
最新发布
2301_80373479的博客
08-17 1847
带你探索堆的奥秘
锐捷交换机去堆叠技术详解
01-31
### 锐捷交换机去堆叠技术详解 #### 第一章 厎叠方案概述 ##### 1.1 技术产生背景 随着数据中心规模的不断扩大和技术的发展，网络架构也经历了从传统三层到扁平化的演进过程。在这一过程中，网络设备之间的堆叠...
C语言实现基于最大堆和最小堆的堆排序算法示例
09-02
堆排序是一种高效的比较排序算法，它利用了数据结构中的“堆”这一概念。堆是一种特殊的树形数据结构，每个节点都有一个值，且满足堆的性质：对于最大堆，父节点的值总是大于或等于其子节点的值；对于最小堆，父节点...
解读堆排序算法及用C++实现基于最大堆的堆排序示例
12-25
1、堆排序定义 n个关键字序列Kl，K2，…，Kn称为堆，当且仅当该序列满足如下性质(简称为堆性质)： (1) ki≤K2i且ki≤K2i+1 或(2)Ki≥K2i且ki≥K2i+1(1≤i≤ ) 若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的...
java实现堆的操作方法(建堆,插入,删除)
08-28
在计算机科学中，堆是一种特殊的完全二叉树，满足任意节点的值都大于或等于其子节点的值（大顶堆），或者小于或等于其子节点的值（小顶堆）。堆通常用于实现优先队列、堆排序等数据结构和算法。在Java中实现堆的操作...
优先队列总结（堆）
weixin_33811961的博客
11-26 119
为什么80%的码农都做不了架构师？>>> ...
二叉堆与堆排序详解
"堆排序是一种基于完全二叉树结构的高效排序算法，它利用了堆的特性进行排序。堆可以是大顶堆或小顶堆，其中大顶堆的每个节点都大于或等于其子节点，小顶堆则相反。在完全二叉树中，从根节点到叶子节点的路径上的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值