1. 怎样用c语言中堆排序实现一个数组a[10]的排序
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int sort_function( const void *a, const void *b);
char list[5][4] = { "cat", "car", "cab", "cap", "can" };
int main(void)
{
int x;
qsort((void *)list, 5, sizeof(list[0]), sort_function); // 调用快速排序
for (x = 0; x < 5; x++)
printf("%s\n", list[x]);
return 0;
}
int sort_function( const void *a, const void *b)
{ //自已要定义一个简单的比较函数就可
return( strcmp((char *)a,(char *)b) );
}
// C++中自身有一个通用的快速 qsort,可以用它 ,自已要定义一个简单的比较函数就可
2. 跪求大神用C语言编程堆排序 不是快速（冒泡）排序！！
void HeapSortData(int SortData[], int Length)
{
int i=0;
//将Hr[0,Lenght-1]建成大根堆
for (i=Length/2-1; i>=0; i--)
{
HeapAdjust(SortData, i, Length);
}
for (i=Length-1; i>0; i--)
{
//与最后一个记录交换
int tmpData =SortData[0];
SortData[0] =SortData[i];
SortData[i] =tmpData;
//将H.r[0..i]重新调整为大根堆
HeapAdjust(SortData, 0, i);
}
return;
}
3. 希尔排序，选择排序，插入排序，堆排序的c语言实现
希尔排序算法
void Shellinsert ( SqList &L, int dk ) {
// 对顺序表 L 作一趟希尔插入排序。此算法和一趟直接插入排序相比，作了以下修改：
// (1) 前后记录为止的增量是 dk，而不是 1；
// (2) r[0] 只是暂存单元，而不是哨兵。当 j <= 0 时，插入位置已经找到。
for ( i = dk+1; i <=L.length; ++i )
if ( L.r[i].key < L.r[i-dk].key ) { // 需要将 L.r[i] 插入有序增量子表
L.r[0] = L.r[i]; // 暂存在 L.r[0]
for ( j = i-dk; j > 0 && ( L.r[0].key < L.r[j].key ); j -= dk )
L.r[j+dk] = L.r[j]; // 记录后移，查找插入位置
L.r[j+dk] = L.r[0]; // 插入到正确位置
} // if 结束
} // ShellInsert
4. C语言堆排序 几个不明白的地方。高手帮忙啊！~
这里为什么是i=n/2-1，初学者可能会不明白。
你这样考虑。
首先对于叶子节点，我们没有必要进行维护操作，也就是没有必要调用你的HeapAdjust
函数
为什么呢？因为叶子节点没有孩子。就算调用了，也不起作用。
所以你应该从n/2-1下标所对应的节点开始，一直维护到0下标对于的节点。
n/2-1是编号最大的非叶子节点，而0号节点是根节点
至于这里为什么是--i，因为这里是自低向上的维护，最后一个维护的必然是根节点。
实际上这两句话的作用是建堆。
for(i=n/2-1;i>=0;--i)
HeapAdjust(data,i,n-1);
我画了个草图
5. 数据结构（C语言版） 堆排序
#include<stdio.h>
#include<stdlib.h>
#include <math.h>
#define L 8 //排序元素个数
#define FALSE 0
#define TRUE 1
typedef struct
{
int key;
char otherinfo;
}RecType;
typedef RecType Seqlist[L+1];
int num; //定义排序趟数的全局变量
Seqlist R;
//直接插入排序
void Insertsort()
{
int i,j,k,m=0;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
for(i=2;i<=L;i++)
{
if(R[i].key<R[i-1].key)
{
R[0]=R[i];
j=i-1;
while(R[0].key<R[j].key)
{
R[j+1]=R[j];
j--;
}
R[j+1]=R[0];
}
m++;
printf("\t\t第%d趟排序的结果为（按回车键开始排序）：\n\t\t",m);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
printf("\n\t\t排序最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
//希尔排序
void Shellsort()
{
int i,j,gap,x,m=0,k;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
gap=L/2;
while(gap>0)
{
for(i=gap+1;i<=L;i++)
{
j=i-gap;
while(j>0)
{
if(R[j].key>R[j+gap].key)
{
x=R[j].key;
R[j].key=R[j+gap].key;
R[j+gap].key=x;
j=j-gap;
}
else
{
j=0;
}
}
}
gap=gap/2;
m++;
printf("\t\t第%d趟排序的结果为（按回车键开始排序）：\n\t\t",m);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
printf("\n\t\t排序最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
//冒泡排序
void Bubblesort()
{
int i,j,k;
int exchange;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
for(i=1;i<L;i++)
{
exchange=FALSE;
for(j=L;j>=i+1;j--)
{
if(R[j].key<R[j-1].key)
{
R[0].key=R[j].key;
R[j].key=R[j-1].key;
R[j-1].key=R[0].key;
exchange=TRUE;
}
}
if(exchange)
{
printf("\t\t第%d趟排序的结果为（按回车键开始排序）：\n\t\t",i);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
}
printf("\n\t\t排序最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
int Partition(int i,int j) //i和j为形式参数，分别代表low和high
{
RecType pirot=R[i];
while(i<j)
{
while(i<j&&R[j].key>=pirot.key)
{
j--;
}
if(i<j)
{
R[i++]=R[j];
}
while(i<j&&R[j].key<=pirot.key)
{
i++;
}
if(i<j)
{
R[j--]=R[i];
}
}
R[i]=pirot;
return i;
}
//递归排序
void Quicksort(int low,int high)
{
int pirotpos,k;
if(low<high)
{
pirotpos=Partition(low,high);
num++;
printf("\t\t第%d趟排序的结果为（按回车键开始排序）：\n\t\t",num);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
Quicksort(low,pirotpos-1);
Quicksort(pirotpos+1,high);
}
}
//选择排序
void Selectsort()
{
int i,j,k,h;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
for(i=1;i<L;i++)
{
h=i;
for(j=i+1;j<=L;j++)
{
if(R[j].key<R[h].key)
{
h=j;
}
}
if(h!=j)
{
R[0]=R[i];
R[i]=R[h];
R[h]=R[0];
}
printf("\t\t第%d趟排序的结果为（按回车键开始排序）：\n\t\t",i);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
printf("\n\t\t排序最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
void Merge(int low,int mm,int high)
{
int i=low,j=mm+1,p=0;
RecType *R1;
R1=new RecType[high-low+1];
if(!R1)
{
printf("内存不足！");
}
while(i<=mm&&j<=high)
{
R1[p++]=(R[i].key<=R[j].key)?R[i++]:R[j++];
}
while(i<=mm)
{
R1[p++]=R[i++];
}
while(j<=high)
{
R1[p++]=R[j++];
}
for(p=0,i=low;i<=high;p++,i++)
{
R[i]=R1[p];
}
}
void MergePass(int length)
{
int i;
for(i=1;i+2*length-1<=L;i=i+2*length)
{
Merge(i,i+length-1,i+2*length-1);
}
if(i+length-1<L)
{
Merge(i,i+length-1,L);
}
}
//归并排序
void Mergesort()
{
int length,k,m=0,i;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
for(length=1;length<L;length*=2)
{
MergePass(length);
m++;
printf("\t\t第%d趟排序的结果为（按回车键开始排序）：\n\t\t",m);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
printf("\n\t\t排序最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
//堆建
void CreateHeap(int root,int index)
{
int j,temp,finish;
j=2*root;
temp=R[root].key;
finish=0;
while(j<=index&&finish==0)
{
if(j<index)
{
if(R[j].key<R[j+1].key)
{
j++;
}
}
if(temp>=R[j].key)
{
finish=1;
}
else
{
R[j/2].key=R[j].key;
j=j*2;
}
}
R[j/2].key=temp;
}
//堆排序
void Heapsort()
{
int i,j,temp,k;
for(i=(L/2);i>=1;i--)
{
CreateHeap(i,L);
}
for(i=L-1,k=1;i>=1;i--,k++)
{
temp=R[i+1].key;
R[i+1].key=R[1].key;
R[1].key=temp;
CreateHeap(1,i);
printf("\t\t第%d趟排序的结果为（按回车键开始排序）：\n\t\t",k);
for(j=1;j<=L;j++)
{
printf("%5d",R[j].key);
}
getchar();
printf("\n");
}
}
void Heap()
{
int i;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
getchar();
printf("\n");
Heapsort();
printf("\n\t\t排序最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
main()
{
Seqlist S;
int i,k;
char ch1,ch2,q;
printf("\n\t\t请输入%d个待排序的数据（按回车键分隔）：\n\t\t",L);
for(i=1;i<=L;i++)
{
scanf("%d",&S[i].key);
getchar();
printf("\t\t");
}
printf("\n\t\t数据输入完毕！");
ch1='y';
while(ch1=='y'||ch1=='Y')
{
printf("\n");
printf("\n\t\t 排 序 子 系 统 \n");
printf("\n\t\t*******************************************\n");
printf("\n\t\t* 1--------更新排序数据 *\n");
printf("\n\t\t* 2--------直接插入排序 *\n");
printf("\n\t\t* 3--------希 尔 排 序 *\n");
printf("\n\t\t* 4--------冒 泡 排 序 *\n");
printf("\n\t\t* 5--------快 速 排 序 *\n");
printf("\n\t\t* 6--------选 择 排 序 *\n");
printf("\n\t\t* 7--------归 并 排 序 *\n");
printf("\n\t\t* 8--------堆 排 序 *\n");
printf("\n\t\t* 0--------退 出 *\n");
printf("\n\t\t*******************************************\n");
printf("\n\t\t请选择菜单号（0到8）");
scanf("%c",&ch2);
getchar();
for(i=1;i<=L;i++)
{
R[i].key=S[i].key;
}
switch(ch2)
{
case '1':
printf("\n\t\t请输入%d个待排序数据（按回车键分隔）\n\t\t",L);
for(i=1;i<=L;i++)
{
scanf("%d",&S[i].key);
getchar();
printf("\t\t");
}
printf("\n\t\t数据输入完毕！");
break;
case '2':
Insertsort();
break;
case '3':
Shellsort();
break;
case '4':
Bubblesort();
break;
case '5':
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
num=0;
Quicksort(1,L);
printf("\n\t\t排序最终结果是：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
printf("\n");
break;
case '6':
Selectsort();
break;
case '7':
Mergesort();
break;
case '8':
Heap();
break;
case '0':
ch1='n';
break;
default:
system("cls");
printf("\n\t\t对不起，您输入有误，请重新输入！\n");
break;
}
if(ch2!='0')
{
if(ch2=='2'||ch2=='3'||ch2=='4'||ch2=='5'||ch2=='6'||ch2=='7'||ch2=='8')
{
printf("\n\n\t\t排序完毕！");
printf("\n\t\t按回车键继续！");
q=getchar();
if(q!='\xA')
{
getchar();
ch1='n';
}
}
}
}
}
6. 请问c语言中的 堆排序 原理是什么，最好有个例子说明一下，谢谢！
如果是最大堆，那么堆顶元素就是最大的。并且它是一种二叉树的形式。因此它的左右子树也是一个最大堆。也就说左子树和右子树的根都是当前子树中最大的元素。堆排序的原理就是维护一个最大堆。可以详见数据结构书，那段代码写的相当简洁易懂。初始化堆时，要弄明白为什么是更新一半的元素。你可以在纸上画一画，对每一个元素从二叉树上从1开始标号。会发现标号为1 ， 2，..n/2 的结点刚好可以覆盖二叉树的所有路径，并且是从 n/2 到 1 去更新堆，这样的话就可以构成一个初始化的最大堆。每次更新最大堆时，都是沿着左右子树的路径一次更新，要左右子结点较大的元素往上移动，知道更新的元素大于左右子树的结点值。那么就成了一个新的最大堆。复杂度就是二叉树数的层数。即每次更新复杂度是log(n).
7. c语言 堆排序算法升序排列N个数
#include<cstdio>
intarr[120000];
intmain()
{
intT,n;
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
for(inti=1;i<=n;i++)
scanf("%d",&arr[i]);
sort(arr+1,arr+n+1);
for(inti=1;i<=n;i++)
printf("%d%c",arr[i],i==n?' ':'';
}
return0;
}
8. C语言堆排序法谁能通俗易懂又清晰地讲解一下谢谢
您可以找本数据结构的书看看，比如清华严尉敏的《数据结构》
以下摘抄于 http://student.zjzk.cn/course_ware/data_structure/web/paixu/paixu8.4.2.1.htm 这个网站的讲解挺不错，您可以看看
1、 堆排序定义
n个关键字序列Kl，K2，…，Kn称为堆，当且仅当该序列满足如下性质(简称为堆性质)：
(1) ki≤K2i且ki≤K2i+1 或(2)Ki≥K2i且ki≥K2i+1(1≤i≤ )
若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。
3、堆排序特点
堆排序(HeapSort)是一树形选择排序。
堆排序的特点是：在排序过程中，将R[l..n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系【参见二叉树的顺序存储结构】，在当前无序区中选择关键字最大(或最小)的记录。
5、堆排序
堆排序利用了大根堆(或小根堆)堆顶记录的关键字最大(或最小)这一特征，使得在当前无序区中选取最大(或最小)关键字的记录变得简单。
（1）用大根堆排序的基本思想
① 先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区
② 再将关键字最大的记录R[1](即堆顶)和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key
③由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。
……
直到无序区只有一个元素为止。
（2）大根堆排序算法的基本操作：
① 初始化操作：将R[1..n]构造为初始堆；
② 每一趟排序的基本操作：将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换，然后将新的无序区调整为堆(亦称重建堆)。
注意：
①只需做n-1趟排序，选出较大的n-1个关键字即可以使得文件递增有序。
②用小根堆排序与利用大根堆类似，只不过其排序结果是递减有序的。堆排序和直接选择排序相反：在任何时刻，堆排序中无序区总是在有序区之前，且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止。
（3）堆排序的算法：
void HeapSort(SeqIAst R)
{ //对R[1..n]进行堆排序，不妨用R[0]做暂存单元
int i；
BuildHeap(R)； //将R[1-n]建成初始堆
for(i=n;i>1；i--){ //对当前无序区R[1..i]进行堆排序，共做n-1趟。
R[0]=R[1]；R[1]=R[i];R[i]=R[0]； //将堆顶和堆中最后一个记录交换
Heapify(R，1，i-1)； //将R[1..i-1]重新调整为堆，仅有R[1]可能违反堆性质
} //endfor
} //HeapSort
9. 计算机C语言的堆排序原理，最好是一个排序的例子，举数据进行现场排序
#include<stdio.h>
#define N 6
int j,k;
//建堆函数
void build(int *a,int i,int n){
int tmp;
k=i;
j=2*k+1;
while(j<=n){
if((j<n)&&a[j]<a[j+1])
j++;
if(a[k]>=a[j])
break;
tmp=a[k];
a[k]=a[j];
a[j]=tmp;
k=j;
j=2*j+1;
}
}
//打印数组元素
void prnt(int *a,int n){
int i;
printf("\n");
for(i=0;i<n;i++)
{
printf("%d ",a[i]);
}
printf("\n");
}
//打印堆函数
void prnthp(int *a,int b1,int b2){
int size;
int h=0,sum=0,item=1;
int i,j,cnt,start,tmp;
size=b2-b1+1;
while(sum<=size){
sum+=item;
h++;
item*=2;
}
item=1;
cnt=0;
start=b1;
tmp=1;
printf("\n========================================\n");
printf(" 堆：\n");
while(1){
for(i=0;i<h;i++){
for(j=0;j<h-i;j++)
printf(" ");
/* for(j=0;j<i+1;j++)
printf(" ");*/
for(j=0;j<tmp;j++){
if(cnt>size-1)
goto end;
printf("%4d",a[cnt++]);
}
printf("\n");
tmp*=2;
}
}
end:
printf("\n");
}
//打印排序好地数组
void prntar(int *a,int b2,int len){
int i;
printf(" 已排序： \n");
for(i=0;i<b2;i++)
printf(" ");
for(i=b2;i<=len;i++)
printf("%d ",a[i]);
printf("\n");
}
int main(){
int a[50];
int i;
int tmp;
int sum;
int len;
printf(" 堆排序\n");
printf("\n=============================================\n");
printf("\n请输入堆排序的数组元素个数，回车结束:\n");
scanf("%d",&len);
printf("\n请输入待排序的数组以回车结束：\n");
for(i=0;i<len;i++)
scanf("%d",&a[i]);
tmp=1;sum=0;
while (sum+tmp<=len){
sum+=tmp;
tmp*=2;
}
printf("\n==============================================================\n");
printf("\n 初始数组：\n");
prnt(a,len);
for(i=sum-1;i>=0;i--)
build(a,i,len-1);
prnthp(a,0,len-1);
for(i=0;i<len-1;i++){
tmp=a[0];
a[0]=a[len-1-i];
a[len-1-i]=tmp;
build(a,0,len-2-i);
prnthp(a,0,len-2-i);
prntar(a,len-1-i,len-1);
}
printf("\n===================================\n");
printf("\n 排序结果：\n");
prnt(a,len);
printf("\n=======================================\n");
return 0;
}
10. c语言堆排序代码
#include<stdio.h>
void shift(int a[] , int i , int m)
{
int k , t;
t = a[i]; k = 2 * i + 1;
while (k < m)
{
if ((k < m - 1) && (a[k] < a[k+1])) k ++;
if (t < a[k]) {a[i] = a[k]; i = k; k = 2 * i + 1;}
else break;
}
a[i] = t;
}
void heap(int a[] , int n) //a 为排序数组，n为数组大小（编号0-n-1）
{
int i , k;
for (i = n/2-1; i >= 0; i --) shift(a , i , n);
for (i = n-1; i >= 1; i --)
{
k = a[0]; a[0] = a[i]; a[i] = k;
shift(a , 0 , i);
}
}
void main()
{
int a[10],i;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
heap(a,10);
for(i=0;i<10;i++)
printf("%d",a[i]);
}