java 实现堆排序算法_C程序实现堆排序算法

java 实现堆排序算法

Heap Sort is a comparison-based sorting algorithm that makes use of a different data structure called Binary Heaps. Let us understand some important terms,

堆排序是一种基于比较的排序算法，该算法利用称为二进制堆的不同数据结构。让我们了解一些重要的术语，

Complete Binary Tree: A tree is complete when all the levels (except of course the last level) are completely filled, i.e. all the parent nodes have two children nodes each and all the nodes are as far left as possible which means first we fill the left node and then the right.
完整的二叉树 ：当所有级别(当然，最后一个级别除外)都被完全填充时，即所有树的父节点都有两个子节点，并且所有节点都尽可能靠左，这意味着一棵树完成了。左节点，然后右。
Binary Heap: It is a complete binary tree but there is an order of elements from parent to children in Binary Heap. They can be of two types,
Binary Heap ：这是一个完整的二叉树，但是Binary Heap中从父级到子级都有一个元素顺序。它们可以有两种类型，
1. Max Binary Heap or Max Heap where the parent node is greater than its two children nodes.
2. 最大父节点大于其两个子节点的最大二进制堆或最大堆 。
3. Min Binary Heap or Min Heap where the parent node is smaller than its children nodes.最小二进制堆或最小堆，其中父节点小于其子节点。

The main() function of Heap Sort is to call the heapify() function which leads to the building of a max heap and then the largest element is stored in the last position of the array as so on till only one element is left in the heap. Array representation of heap is preferred because it occupies less space and also it is easy to reference the root and children nodes.

堆排序的main()函数将调用heapify()函数，该函数将导致建立最大堆，然后将最大元素存储在数组的最后一个位置，依此类推，直到在数组中只剩下一个元素为止。堆。堆的数组表示形式是首选的，因为它占用较少的空间，并且易于引用根节点和子节点。

Algorithm (Considering Max heap):

算法(考虑最大堆)：

First, we form a Max Heap such that the first node or the root node is the largest element. This step takes O(N) time complexity.
首先，我们形成一个最大堆，以使第一个节点或根节点成为最大元素。此步骤需要O(N)时间复杂度。
Next, we swap the root element with the last element of the heap and reduce the size of heap by 1.
接下来，我们将根元素与堆的最后一个元素交换，并将堆的大小减小1。
Repeat steps 1 and 2 are till only 1 element is left.
重复步骤1和2，直到仅剩1个元素。

How to build the Heap?

如何建立堆？

The heapify procedure can be applied to a node only when its children nodes are heapified. Therefore, we start the heapification with the last non-leaf node. To find the first non-leaf node, the following formula is used: First non-leafy node = lower bound (n/2)

仅当对子节点进行堆化时，才能将heapify过程应用于该节点。因此，我们从最后一个非叶子节点开始堆化。要找到第一个非叶子节点，请使用以下公式： 第一个非叶子节点=下界(n / 2)

Hence, if there are 5 elements in the heap, the first non-leafy node would be the second node or the node at index 1.

因此，如果堆中有5个元素，则第一个非叶节点将是第二个节点或索引为1的节点。

Pseudo Code:

伪代码：

Heap_Sort (arr[], n)
{
// Creating the initial Max heap
for i = n/2 – 1 to 0:
heapify(arr, n, i)
// Swapping largest element and repeating the steps further
for i = n-1 to 0:
swap(arr[0], arr[i]
heapify(arr, n, i)
}
Heapify (arr[], n, i)
{
int largest = i;
int left = 2*i + 1; // Left child
int right = 2*i + 2; // Right child
// Check if left child exists and is larger than root
If (left < n && arr[left] > arr[largest]):
Largest = left;
// Check if right child exists and is larger than largest
If (right < n && arr[right] > arr[largest]):
largest = right;
// Change root, if root is not the largest
If(largest != i)
Swap(arr[i], arr[largest])
Heapify(arr, n, largest); //Repeat till max heap is obtained
}

Time Complexity:

时间复杂度：

The time complexity of Heap sort is:

堆排序的时间复杂度为：

Worst Case = O(N log N)
最坏情况= O(N log N)
Average Case = Ɵ(N log N)
平均情况=Ɵ(N log N)
Best Case = Ω(N log N)
最佳情况=Ω(N log N)
Space Complexity: Ɵ(1)
空间复杂度：Ɵ(1)

The time complexity of Heapify is O(log N) and that of Build_heap / Heap_Sort is O(N). The overall complexity of Heap_Sort is therefor, O(N log N).

Heapify的时间复杂度为O(log N)，而Build_heap / Heap_Sort的时间复杂度为O(N)。因此，Heap_Sort的总体复杂度为O(N log N)。

Heap Sort Implementation:

堆排序实现：

#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 left, right, largest;
largest = i;
left = 2 * i + 1;
right = 2 * i + 2;
// Check if left child exists and is larger than its parent
if (left < n && arr[left] > arr[largest])
largest = left;
// Check if right child exists and larger than its parent
if (right < n && arr[right] > arr[largest])
largest = right;
// if root is not the largest
if (largest != i) {
swap(&arr[i], &arr[largest]); //make root the largest
heapify(arr, n, largest); // Apply heapify to the largest node
}
}
void heap_sort(int arr[], int n)
{
int i;
for (i = (n / 2) - 1; i >= 0; i--)
heapify(arr, n, i);
for (i = n - 1; i >= 0; i--) {
swap(&arr[0], &arr[i]); //Move the largest element at root to the end
heapify(arr, i, 0); //Apply heapify to reduced heap
}
}
int main()
{
int arr[] = { 20, 13, 34, 56, 12, 10 };
int n = sizeof(arr) / sizeof(arr[0]);
printf("Array:\n");
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
heap_sort(arr, n);
printf("\nAfter performing Heap Sort:\n");
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
return 0;
}

Output:

输出：

Array:
20 13 34 56 12 10
After performing Heap Sort:
10 12 13 20 34 56

Applications:

应用范围：

Job Scheduling: In Linux OS is used due to low space and time complexity
作业调度 ：由于空间和时间复杂度低，在Linux OS中使用
Graph Algorithms: Djikstar's Algorithm, Prim's Algorithm and Huffman Coding
图算法 ：Djikstar算法，Prim算法和霍夫曼编码