HeapSort

最小堆排序

先用一个筛的方法形成一个最小堆

那什么是最小堆呢?

也就是每一个父节点都比它的左右儿子大

如何筛?

从最后一个非叶节点开始(也就是最后一个有儿子的节点),先比较它的左右儿子大小,和最大的交换。

最小堆形成后 根节点是最大的

把根节点和最后一个节点交换  那么最后一个节点就是排完序的最大值  存到数组中

然后继续用筛的方法  从第一个节点到去掉最后一个节点为止进行构造最小堆

详细看代码

 1 #define N 11
 2 #include "stdio.h"
 3 void HeapAdjust(int a[],int s,int n)
 4 {
 5     int j,t;
 6     while(2*s<=n)                        //有儿子则进行循环
 7     {
 8         j=2*s;
 9         if(a[j]<a[j+1] && j+1<=n)        //比较左右儿子大小 第二个判断排除了只有一个儿子的情况
10             j++;
11         if(a[s]<a[j])                    //父节点和较大儿子交换
12         {
13             t=a[s];
14             a[s]=a[j];
15             a[j]=t;
16             s=j;                        //父节点等于较大儿子节点 继续向下筛选
17         }
18         else                            //节点最大了就不用筛选  注意 堆的筛选是建立在子树已经是一个堆的情况下
19             break;
20     }
21 }
22 void HeapSort(int a[],int n)
23 {
24     int i,t;
25     for(i=n/2;i>=1;i--)                    //从最后一个非页节点开始进行筛
26         HeapAdjust(a,i,n);
27     for(i=n;i>=1;i--)
28     {
29         t=a[1];
30         a[1]=a[i];
31         a[i]=t;                            //把根节点和最后一个节点进行交换
32         HeapAdjust(a,1,i-1);            //从根节点开始到去除最后一个节点 继续进行筛
33     }
34 }
35 main()
36 {
37     int i,a[11];
38     a[0]=-1;
39     for(i=1;i<=N;i++)
40         scanf("%d",&a[i]);
41     HeapSort(a,N);
42     for(i=1;i<=N;i++)
43         printf("%d ",a[i]);
44 }
时间: 2024-10-19 05:13:50

HeapSort的相关文章

排序算法三:堆排序(Heapsort)

堆排序(Heapsort)是一种利用数据结构中的堆进行排序的算法,分为构建初始堆,减小堆的元素个数,调整堆共3步. (一)算法实现 1 protected void sort(int[] toSort) { 2 buildHeap(toSort); 3 for (int i = toSort.length - 1; i > 0; i--) { 4 CommonUtils.swap(toSort, 0, i); 5 adjustHeap(toSort, 0, i); 6 } 7 } 8 9 /**

【Sort】HeapSort

堆排序,时间复杂度O(N log N),实际使用中慢于使用Sedgewick增量的增量排序. 大致思路: 1.先在数组中建堆,如果是增量排序,则需要建一个大堆 2.每循环一次,把最大的数,也就是nums[0],放入堆尾,同时把nums[0]下滤 1 void heapsort(int *nums,int n) 2 { 3 int i; 4 for(i=n/2;i>=0;i--) 5 percdown(nums,i,n); 6 for(i=n-1;i>0;i--) 7 { 8 nums[0]^=

Heapsort 堆排序算法详解(Java实现)

Heapsort (堆排序)是最经典的排序算法之一,在google或者百度中搜一下可以搜到很多非常详细的解析.同样好的排序算法还有quicksort(快速排序)和merge sort(归并排序),选择对这个算法进行分析主要是因为它用到了一个非常有意思的算法技巧:数据结构 - 堆.而且堆排其实是一个看起来复杂其实并不复杂的排序算法,个人认为heapsort在机器学习中也有重要作用.这里重新详解下关于Heapsort的方方面面,也是为了自己巩固一下这方面知识,有可能和其他的文章有不同的入手点,如有错

HeapSort自己yy-未完成

#include <iostream> #include <cstdio> using namespace std; const int maxn=1e5+7; int a[maxn]; int HeapSize; int n; //原子操作 //不要总想着搞一个大新闻,一次操作干太多操作 //只要不符合堆的性质我们就交换 void Heapify(){ int id=1; while(id<=HeapSize){ int lson=2*id; int rson=2*id+1

algorithm ch6 heapsort

堆排序利用的是堆这种数据结构来对进行排序,(二叉)堆数据结构是一种数组对象,它可以被视为一棵完全的二叉树,树的每个节点与数组中存放该节点的值得那个元素对应.这里使用最大堆进行排序算法设计,最大堆就是parent(i) > leftchild(i) 且parent(i) > rightchild(i),首先利用迭代法进行建堆. void MaxHeapify(int *a, int node, int iHeapSize) { int iIndexL = left(node); int iInd

[硕.Love Python] HeapSort(堆排序)

def adjust(a, root, n):     k = a[root-1]     c = root * 2     while c <= n:         if c + 1 <= n and a[c] > a[c-1]:             c += 1         if a[c-1] <= k:             break         a[c/2-1] = a[c-1]         c *= 2     a[c/2-1] = k def he

HeapSort 堆排序 基于伪代码实现

GIF 动态图 伪代码 /* From Wikipedia, the free encyclopedia */ 1.父子节点特征 iParent = floor((i-1) / 2);iLeftChild = 2*i + 1;iRightChild = 2*i + 2; 2.算法伪代码 /* 保持原汁原味就不翻译了 =.= */ procedure heapsort(a, count) is input: an unordered array a of length count (Build t

算法导论学习-heapsort

heap的定义:如果数组a[1,....n]满足:a[i]>a[2*i] && a[i]>a[2*i+1],1<=i<=n/2,那么就是一个heap,而且是max-heap heap有两种,max-heap 和 min-heap,其中min-heap的性质与上面所述相反,即 a[i]<a[2*i] && a[i]<a[2*i+1]. 这里以max-heap为例说明heap的三种基本操作,即Max-Heap-Maintenance, Bui

堆排序(heapsort)

堆数据结构是一种数组对象,它可以被视为一棵完全二叉树.时间复杂度为:O(n*logn),空间复杂度:O(1); 平均时间复杂度和最坏时间复杂度都为:O(n*logn),但堆排序是不稳定排序. 堆排序思路: 1.建立小堆:把堆看成一个完全二叉树,然后从这棵树的最大非叶子节点开始,比较它与它的左儿子与 右儿子的大小,若大于它的儿子,则与最小的交换,交换位置后然后继续与它现在位置的儿子比较:若小于它的儿子 ,则不用交换,直接跳到下一个非叶子节点,重复以上步骤. 2.输出排序的结果:将堆顶元素输出,然后