堆排序

// Console.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>

using namespace std;

//array 是待调整的堆数组，i是待调整的数组元素的位置，nlength是数组的长度
//本函数功能是：根据数组array构建大根堆
void HeapAdjust(int array[], int i, int nLength)
{
int nChild;
int nTemp;

for (nTemp = array[i]; 2 *i + 1 < nLength; i = nChild)
{
//子结点的位置=2*（父结点位置）+ 1
nChild = 2 *i + 1;

// 得到子结点中较大的结点
if(nChild < nLength - 1 && array[nChild + 1] > array[nChild])
++nChild;

// 如果较大的子结点大于父结点那么把较大的子结点往上移动，替换它的父结点
if(nTemp < array[nChild])
{
array[i] = array[nChild];
}
else
{
break;
}

//最后把需要调整的元素值放到合适的位置
array[nChild] = nTemp;

}
}

//堆排序算法
void HeapSort(int array[],int length)
{
//调整序列的前半部分元素，调整完之后第一个元素是序列的最大的元素
for(int i = length/2 - 1; i >= 0; --i)
{
HeapAdjust(array,i,length);
}

//从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
for( i = length - 1; i > 0; --i)
{
swap(array[0],array[i]);
HeapAdjust(array,0,i);
}
}

typedef struct
{
int *r;
int length;
}SqList; //定义一个线性表用于存放数据元素

void HeapAdjust1(SqList&L, int s, int m)
{
//已知L.r[s...m]中记录除L.r[s]外均满足堆的定义，本函数用于使L.r[s...m]成为一个大顶堆
int j;
int e = L.r[s];

for(j = 2 * s; j <= m; j*=2)
{
if(j <m && L.r[j] < L.r[j + 1])
++j;

if(e >= L.r[j]) break;

L.r[s] = L.r[j];

s = j;
}

L.r[s] = e;
}

void HeapSort1(SqList& L)
{
int i,e;

for(i=L.length/2; i > 0; --i)
HeapAdjust1(L,i,L.length);

for( i = L.length; i > 1; --i)
{
//将大顶堆的顶记录和最后一个记录相互交换
e = L.r[1];
L.r[1] = L.r[i];
L.r[i] = e;

HeapAdjust1(L,1,i-1);
}
}

int main(int argc, char* argv[])
{
int arr[6] = {10,15,56,30,25,70};

//HeapSort(arr,6);
SqList L;
L.r = arr;
L.length = 6;

HeapSort1(L);

for(int i = 0; i < 6; ++i)
{
std::cout<<L.r[i]<<" ";
}

system("pause");

return 0;
}

/

const int HEAP_SIZE = 13; //堆積樹大小

/*左子結點*/
int left(int i)
{
return (2 * i + 1);
}

/*右子結點*/
int right(int i)
{
return (2 * i + 2);
}

/*單一子結點最大堆積樹調整*/
void Max_Heapify(int A[], int i, int heap_size)
{
int l = left(i);
int r = right(i);
int largest;
int temp;
if(l < heap_size && A[l] > A[i])
{
largest = l;
}
else
{
largest = i;
}
if(r < heap_size && A[r] > A[largest])
{
largest = r;
}
if(largest != i)
{
temp = A[i];
A[i] = A[largest];
A[largest] = temp;
Max_Heapify(A, largest, heap_size);
}
}

/*建立最大堆積樹*/
void Build_Max_Heap(int A[])
{
for(int i = (HEAP_SIZE-1)/2; i >= 0; i--)
{
Max_Heapify(A, i, HEAP_SIZE);
}
}

/*印出樹狀結構*/
void print(int A[])
{
for(int i = 0; i < HEAP_SIZE;i++)
{
printf("%d ", A[i]);
}
printf("\n");
}

/*堆積排序程序碼*/
void HeapSort(int A[], int heap_size)
{
Build_Max_Heap(A);
int temp;
for(int i = heap_size - 1; i >= 0; i--)
{
temp = A[0];
A[0] = A[i];
A[i] = temp;
Max_Heapify(A, 0, i);
}
print(A);
}

/*輸入資料並做堆積排序*/
int main(int argc, char* argv[])
{
int A[HEAP_SIZE] = {19, 1, 10, 14, 16, 4, 7, 9, 3, 2, 8, 5, 11};
HeapSort(A, HEAP_SIZE);
system("pause");
return 0;
}