堆排序
2005-08-27 23:32
169 查看
以下内容为程序代码:
int heapsort(int p[],int n);
/*
* 堆排序算法在 1964 年由 J. Williams 发明。
* 不稳定,不需要辅助空间。
*/
static int insertheap(int p[],int i,int n);
int heapsort(int p[],int n)
{
int op=0;
int i,temp;
/* 从叶子节点建立对应的上级根节点来建造堆 */
for (i=n/2-1; i>=0; i--) {
op+=insertheap(p,i,n);
}
/* 选择堆顶的最大值与尾部的值交换,
* 把这个值重新插入堆 */
for (i=n-1; i>=1; i--) {
temp=p[0];
p[0]=p;
p[i]=temp;
op++;
op+=insertheap(p,0,i);
}
return op; /* 返回比较操作数 */
}[/i]
static int insertheap(int p[],
int i, /* 要插入的元素的位置 */
int n) /* 列表长度 */
{
int op=0;
int j,temp;
temp=p; /* 要插入的元素已经在根节点位置上,保存它的值 */
j=i*2+1; /* 要比较的节点位置是当前根节点的左子节点 */
/* 要比较的节点位置在列表范围内 */
while (j<n) {
/* 要比较的左子节点有对应的子节点,并且
* 当前根节点的左子节点小于右子节点 */
if (j<n-1 && p[j]<p[j+1])
j++; /* 要比较的节点位置是当前根节点的右子节点 */
/* 要插入的值小于当前做比较的子节点 */
if (temp<p[j]) {
p=p[j]; /* 做比较的子节点的值上移到当前根节点 */
i=j; /* 当前根节点下移到做比较的子节点的位置上 */
j=i*2+1; /* 要比较的节点位置是当前根节点的的左子节点 */
}
/* 要插入的值小于当前做比较的子节点 */
else
break; /* 停止下移 */
op+=2;
/* 分别与左右子节点做比较操作。
* 这是堆排序比快速排序多做比较操作的根源 */
}
p[i]=temp; /* 插入要插入的值 */
op++;
return op;
}
[/i]
/* 要比较的节点位置在列表范围内 */
while (j<n) {
/* 要比较的左子节点有对应的子节点,并且
* 当前根节点的左子节点小于右子节点 */
if (j<n-1 && p[j]<p[j+1])
j++; /* 要比较的节点位置是当前根节点的右子节点 */
/* 要插入的值小于当前做比较的子节点 */
if (temp<p[j]) {
p=p[j]; /* 做比较的子节点的值上移到当前根节点 */
i=j; /* 当前根节点下移到做比较的子节点的位置上 */
j=i*2+1; /* 要比较的节点位置是当前根节点的的左子节点 */
}
/* 要插入的值小于当前做比较的子节点 */
else
break; /* 停止下移 */
op+=2;
/* 分别与左右子节点做比较操作。
* 这是堆排序比快速排序多做比较操作的根源 */
}
p[i]=temp; /* 插入要插入的值 */
op++;
return op;
}
[/i]
static int insertheap(int p[],
int i, /* 要插入的元素的位置 */
int n) /* 列表长度 */
{
int op=0;
int j,temp;
temp=p; /* 要插入的元素已经在根节点位置上,保存它的值 */
j=i*2+1; /* 要比较的节点位置是当前根节点的左子节点 */
/* 要比较的节点位置在列表范围内 */
while (j<n) {
/* 要比较的左子节点有对应的子节点,并且
* 当前根节点的左子节点小于右子节点 */
if (j<n-1 && p[j]<p[j+1])
j++; /* 要比较的节点位置是当前根节点的右子节点 */
/* 要插入的值小于当前做比较的子节点 */
if (temp<p[j]) {
p=p[j]; /* 做比较的子节点的值上移到当前根节点 */
i=j; /* 当前根节点下移到做比较的子节点的位置上 */
j=i*2+1; /* 要比较的节点位置是当前根节点的的左子节点 */
}
/* 要插入的值小于当前做比较的子节点 */
else
break; /* 停止下移 */
op+=2;
/* 分别与左右子节点做比较操作。
* 这是堆排序比快速排序多做比较操作的根源 */
}
p[i]=temp; /* 插入要插入的值 */
op++;
return op;
}
[/i]
/* 要比较的节点位置在列表范围内 */
while (j<n) {
/* 要比较的左子节点有对应的子节点,并且
* 当前根节点的左子节点小于右子节点 */
if (j<n-1 && p[j]<p[j+1])
j++; /* 要比较的节点位置是当前根节点的右子节点 */
/* 要插入的值小于当前做比较的子节点 */
if (temp<p[j]) {
p=p[j]; /* 做比较的子节点的值上移到当前根节点 */
i=j; /* 当前根节点下移到做比较的子节点的位置上 */
j=i*2+1; /* 要比较的节点位置是当前根节点的的左子节点 */
}
/* 要插入的值小于当前做比较的子节点 */
else
break; /* 停止下移 */
op+=2;
/* 分别与左右子节点做比较操作。
* 这是堆排序比快速排序多做比较操作的根源 */
}
p[i]=temp; /* 插入要插入的值 */
op++;
return op;
}
[/i]
int heapsort(int p[],int n);
/*
* 堆排序算法在 1964 年由 J. Williams 发明。
* 不稳定,不需要辅助空间。
*/
static int insertheap(int p[],int i,int n);
int heapsort(int p[],int n)
{
int op=0;
int i,temp;
/* 从叶子节点建立对应的上级根节点来建造堆 */
for (i=n/2-1; i>=0; i--) {
op+=insertheap(p,i,n);
}
/* 选择堆顶的最大值与尾部的值交换,
* 把这个值重新插入堆 */
for (i=n-1; i>=1; i--) {
temp=p[0];
p[0]=p;
p[i]=temp;
op++;
op+=insertheap(p,0,i);
}
return op; /* 返回比较操作数 */
}[/i]
static int insertheap(int p[],
int i, /* 要插入的元素的位置 */
int n) /* 列表长度 */
{
int op=0;
int j,temp;
temp=p; /* 要插入的元素已经在根节点位置上,保存它的值 */
j=i*2+1; /* 要比较的节点位置是当前根节点的左子节点 */
/* 要比较的节点位置在列表范围内 */
while (j<n) {
/* 要比较的左子节点有对应的子节点,并且
* 当前根节点的左子节点小于右子节点 */
if (j<n-1 && p[j]<p[j+1])
j++; /* 要比较的节点位置是当前根节点的右子节点 */
/* 要插入的值小于当前做比较的子节点 */
if (temp<p[j]) {
p=p[j]; /* 做比较的子节点的值上移到当前根节点 */
i=j; /* 当前根节点下移到做比较的子节点的位置上 */
j=i*2+1; /* 要比较的节点位置是当前根节点的的左子节点 */
}
/* 要插入的值小于当前做比较的子节点 */
else
break; /* 停止下移 */
op+=2;
/* 分别与左右子节点做比较操作。
* 这是堆排序比快速排序多做比较操作的根源 */
}
p[i]=temp; /* 插入要插入的值 */
op++;
return op;
}
[/i]
/* 要比较的节点位置在列表范围内 */
while (j<n) {
/* 要比较的左子节点有对应的子节点,并且
* 当前根节点的左子节点小于右子节点 */
if (j<n-1 && p[j]<p[j+1])
j++; /* 要比较的节点位置是当前根节点的右子节点 */
/* 要插入的值小于当前做比较的子节点 */
if (temp<p[j]) {
p=p[j]; /* 做比较的子节点的值上移到当前根节点 */
i=j; /* 当前根节点下移到做比较的子节点的位置上 */
j=i*2+1; /* 要比较的节点位置是当前根节点的的左子节点 */
}
/* 要插入的值小于当前做比较的子节点 */
else
break; /* 停止下移 */
op+=2;
/* 分别与左右子节点做比较操作。
* 这是堆排序比快速排序多做比较操作的根源 */
}
p[i]=temp; /* 插入要插入的值 */
op++;
return op;
}
[/i]
static int insertheap(int p[],
int i, /* 要插入的元素的位置 */
int n) /* 列表长度 */
{
int op=0;
int j,temp;
temp=p; /* 要插入的元素已经在根节点位置上,保存它的值 */
j=i*2+1; /* 要比较的节点位置是当前根节点的左子节点 */
/* 要比较的节点位置在列表范围内 */
while (j<n) {
/* 要比较的左子节点有对应的子节点,并且
* 当前根节点的左子节点小于右子节点 */
if (j<n-1 && p[j]<p[j+1])
j++; /* 要比较的节点位置是当前根节点的右子节点 */
/* 要插入的值小于当前做比较的子节点 */
if (temp<p[j]) {
p=p[j]; /* 做比较的子节点的值上移到当前根节点 */
i=j; /* 当前根节点下移到做比较的子节点的位置上 */
j=i*2+1; /* 要比较的节点位置是当前根节点的的左子节点 */
}
/* 要插入的值小于当前做比较的子节点 */
else
break; /* 停止下移 */
op+=2;
/* 分别与左右子节点做比较操作。
* 这是堆排序比快速排序多做比较操作的根源 */
}
p[i]=temp; /* 插入要插入的值 */
op++;
return op;
}
[/i]
/* 要比较的节点位置在列表范围内 */
while (j<n) {
/* 要比较的左子节点有对应的子节点,并且
* 当前根节点的左子节点小于右子节点 */
if (j<n-1 && p[j]<p[j+1])
j++; /* 要比较的节点位置是当前根节点的右子节点 */
/* 要插入的值小于当前做比较的子节点 */
if (temp<p[j]) {
p=p[j]; /* 做比较的子节点的值上移到当前根节点 */
i=j; /* 当前根节点下移到做比较的子节点的位置上 */
j=i*2+1; /* 要比较的节点位置是当前根节点的的左子节点 */
}
/* 要插入的值小于当前做比较的子节点 */
else
break; /* 停止下移 */
op+=2;
/* 分别与左右子节点做比较操作。
* 这是堆排序比快速排序多做比较操作的根源 */
}
p[i]=temp; /* 插入要插入的值 */
op++;
return op;
}
[/i]
相关文章推荐
- [Unity][Heap sort]用Unity动态演示堆排序的过程(How Heap Sort Works)
- 排序——堆排序
- Go语言用堆排序的方法进行一千万个int随机数排序.
- java实现堆排序
- 堆排序
- 堆排序(Java实现)
- 算法复习之堆排序
- 堆排序
- 四、堆排序
- 序列——堆排序-大根堆(堆大顶)
- 堆排序(算法导论)
- 堆排序
- 快排与堆排序、归并排序的比较
- 堆与堆排序
- 各种常见的排序,冒泡排序,选择排序,插入排序,希尔排序,堆排序,快速排序,基数排序,桶排序
- 经典排序算法 -----冒泡排序,插入排序,快速排序,归并排序,堆排序
- 建堆,以及对堆排序
- HeapSort 堆排序 基于伪代码实现
- 数据结构学习笔记5-寻找最小的k个数(选择排序和堆排序)
- 堆排序