自己实现堆排序

#include <stdio.h>
#include <stdlib.h>

//插入节点上浮过程
NodeUp( int arr[], int i )
{
int j, temp;

temp = arr[i];
j = ( i - 1 ) / 2;

while ( j >= 0 && i != 0 )
{
if ( temp >= arr[j] )
{
break;
}
arr[i] = arr[j];
i = j;
j = ( i - 1 ) / 2;
}
arr[i] = temp;
}

//打印函数
void print(int arr[])
{
int i = 0;
printf( "排序后的数组：\n" );
for ( ; i < 8; ++i )
{
printf("%d\n", arr[i]);
}
}

//在最小堆中插入节点
void MinHeapInsert(int a[], int n, int nInt)
{
a
= nInt;
NodeUp(a, n);
}

//=====================主函数=======================
int main()
{
int a[] = { 1,2,3,5,9,4,10 };

MinHeapInsert(a, 7, 3);//排序后的数组：1，2，3，3，9，4，10，5
print(a);

return 0;
}

#include <stdio.h>
#include <stdlib.h>

//从i节点开始调整,n为节点总数 从0开始计算 i节点的子节点为 2*i+1, 2*i+2
//下调函数
void NodeDown(int a[], int i, int n)
{
int j, temp;

temp = a[i];
j = 2*i + 1;

while ( j < n )
{
if ( j+1 < n && a[j+1] < a[j] )
{
j = j+1;
}
if ( a[j] < temp )
{
a[i] = a[j];
i = j;
j = 2*i + 1;
}
}
a[i] = temp;
}

//交换函数
void swap(int *a, int *b)
{
if (*a != *b)
{
*a ^= *b;
*b ^= *a;
*a ^= *b;
}
}

/*
*   (1) 原堆的样子                                新堆的样子
*        1                                         10
*       / \         把最后一位放置堆顶               /  \
*      2   3        =================>           2    3
*     / \ / \                                   / \  / \
*    5  9 4  10                                5   9 4  1(其实就是把1放到数组最后一位，这个数组编程10，2，3，5，9，4，1)
*
*   (2) 之后执行NodeDown函数第一步交换10和2，3之间小的那个数
*        2
*       / \
*      10  3
*     / \ / \
*    5  9 4  1
*
*   (3) 之后交换10和5，9之间小的那个数
*       2
*      / \
*     5   3
*    / \ / \
*   10 9 4  1
*===================>现在就变成了最终的结果：2，5，3，10，9，4，1
*
*/
void MinHeapDelete(int arr[], int n)
{
swap(&arr[0], &arr[n - 1]);
NodeDown(arr, 0, n - 1);
}

//打印函数
void print(int arr[], int n)
{
int i = 0;
printf( "排序后的数组：\n" );
for ( ; i < n; ++i )
{
printf("%d\n", arr[i]);
}
}

//=====================主函数=======================
int main()
{
int a[] = { 1,2,3,5,9,4,10 };

MinHeapDelete(a, 7);//排序后的数组：2，5，3，10，9，4, 1(1 是被删除的，其实它被换到最后一位了，这里也print出来)
print(a, 7);

return 0;
}

void MinHeapSort(int arr[], int n)
{
int i = n - 1;

for (; i >= 1; --i)
{
swap(&arr[0], &arr[i]);
NodeDown(arr, 0, i);
}
}