使用C语言完成堆排序
时间: 2023-09-17 19:05:33 浏览: 76
### 回答1:
以下是使用C语言实现堆排序的代码:
```
#include <stdio.h>
// 交换两个元素的值
void swap(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
// 堆调整函数
void heapify(int arr[], int n, int i) {
int largest = i; // largest用来记录最大值的位置
int left = 2 * i + 1;
int right = 2 * i + 2;
if (left < n && arr[left] > arr[largest]) {
largest = left;
}
if (right < n && arr[right] > arr[largest]) {
largest = right;
}
if (largest != i) {
swap(&arr[i], &arr[largest]);
heapify(arr, n, largest);
}
}
// 堆排序函数
void heapSort(int arr[], int n) {
// 构建最大堆
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(arr, n, i);
}
// 依次取出最大元素并放到数组末尾
for (int i = n - 1; i >= 0; i--) {
swap(&arr[0], &arr[i]);
heapify(arr, i, 0);
}
}
// 测试函数
int main() {
int arr[] = {12, 11, 13, 5, 6, 7};
int n = sizeof(arr) / sizeof(arr[0]);
heapSort(arr, n);
printf("排序后的数组:\n");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
```
该程序首先定义了一个用于交换元素的函数`swap`,然后定义了堆调整函数`heapify`和堆排序函数`heapSort`。
在`heapify`函数中,每次比较当前节点、左节点和右节点中的最大值,并将最大值与当前节点交换位置,然后递归地调整子树。
在`heapSort`函数中,首先通过调用`heapify`函数构建最大堆,然后每次将最大元素与数组末尾的元素交换位置,然后在数组剩余部分中重新调整堆。
### 回答2:
堆排序是一种经典的排序算法,使用C语言可以很方便地实现该算法。下面是使用C语言完成堆排序的步骤和示例代码。
步骤:
1. 建立初始堆:将待排序的数组视为完全二叉树,从最后一个非叶子节点开始,对每个非叶子节点进行最大堆调整,使得每个非叶子节点的值大于其孩子节点的值。
2. 排序:将堆顶元素(最大值)与堆的最后一个元素交换,然后将剩下的元素重新调整为最大堆。
3. 重复上述步骤,直到整个数组有序。
示例代码:
```c
#include <stdio.h>
// 调整堆,保证以root为根节点的子树满足最大堆性质
void adjustHeap(int arr[], int root, int length) {
int temp = arr[root]; // 保存根节点的值
int child = 2 * root + 1; // 左孩子节点
while (child < length) {
// 如果有右孩子且右孩子的值大于左孩子,则选择右孩子作为child
if (child + 1 < length && arr[child] < arr[child + 1]) {
child++;
}
// 如果根节点大于或等于child,则调整结束
if (temp >= arr[child]) {
break;
}
// 将child的值赋给root
arr[root] = arr[child];
// 以child节点为根节点,继续向下调整
root = child;
child = 2 * root + 1;
}
arr[root] = temp; // 将初始堆调整为最大堆
}
// 堆排序
void heapSort(int arr[], int length) {
// 建立初始堆
for (int i = length / 2 - 1; i >= 0; i--) {
adjustHeap(arr, i, length);
}
// 排序
for (int i = length - 1; i > 0; i--) {
// 将堆顶元素与最后一个元素交换
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
// 调整剩余元素为最大堆
adjustHeap(arr, 0, i);
}
}
int main() {
int arr[] = {9, 3, 5, 8, 2, 7, 1, 6, 4};
int length = sizeof(arr) / sizeof(arr[0]);
printf("排序前的数组:");
for (int i = 0; i < length; i++) {
printf("%d ", arr[i]);
}
printf("\n");
heapSort(arr, length);
printf("排序后的数组:");
for (int i = 0; i < length; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
```
上述示例代码使用C语言实现了堆排序算法。首先,通过`adjustHeap()`函数建立初始堆,然后通过`heapSort()`函数完成排序操作。在`main()`函数中,我们通过示例数组展示了排序前和排序后的结果。执行程序后,输出结果为:
```
排序前的数组:9 3 5 8 2 7 1 6 4
排序后的数组:1 2 3 4 5 6 7 8 9
```
以上就是使用C语言完成堆排序的过程和示例代码。堆排序是一种性能稳定、适用于大规模数据的排序算法,能够在O(nlogn)的时间复杂度下完成排序操作。
### 回答3:
堆排序是一种基于完全二叉堆的排序算法。完全二叉堆可以用数组来表示,其中父节点与子节点的关系是通过索引进行计算。堆排序算法一般分为两个步骤,首先是建堆(Heapify),然后是将最大(或最小)元素交换到堆的末尾,再对剩余元素进行调整恢复堆的性质。
下面是用C语言完成堆排序的代码示例:
#include <stdio.h>
// 交换元素值
void swap(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
// 堆调整
void heapify(int arr[], int n, int i) {
int largest = i; // 将当前节点标记为最大值
int left = 2 * i + 1; // 左子节点索引
int right = 2 * i + 2; // 右子节点索引
// 如果左子节点大于当前节点,将最大值索引设为左子节点索引
if (left < n && arr[left] > arr[largest])
largest = left;
// 如果右子节点大于当前节点,将最大值索引设为右子节点索引
if (right < n && arr[right] > arr[largest])
largest = right;
// 如果最大值不是当前节点,交换节点,并递归调整其子堆
if (largest != i) {
swap(&arr[i], &arr[largest]);
heapify(arr, n, largest);
}
}
// 堆排序
void heapSort(int arr[], int n) {
// 建堆(从最后一个非叶子节点开始向上调整)
for (int i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);
// 交换堆顶元素(最大值)到数组末尾,并递归调整剩余元素
for (int i = n - 1; i >= 0; i--) {
swap(&arr[0], &arr[i]);
heapify(arr, i, 0);
}
}
int main() {
int arr[] = { 12, 11, 13, 5, 6, 7 };
int n = sizeof(arr) / sizeof(arr[0]);
heapSort(arr, n);
printf("排序后的数组:\n");
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
return 0;
}
以上代码实现了堆排序算法。首先通过heapify函数构建初始堆,然后依次将最大值与末尾元素交换,再调整剩余元素以维持堆的性质,直到完成排序。运行后输出排序后的数组:5 6 7 11 12 13。