The heap sort of "turn" algorithm

http://blog.csdn.net/SJF0115/article/details/8610201

Pre-order:

(binary) A heap data structure is an array object that can be treated as a complete binary tree. Each node in the tree corresponds to the element that holds the value of the node in the array.

Each layer of the tree is filled, except for the last layer.

The root of the tree is a[1] (here is starting from 1, also can start from 0), given a node subscript I, the parent node is I/2, the left two children is 2*i, the right son is 2*i+1.

The binary stack satisfies two characteristics:

1. The key value of the parent node is always greater than or equal to (less than or equal to) the key value of any one of the child nodes.

2. The Saozi right subtree of each node is a binary heap (maximum heap or minimum heap).

The maximum heap when the parent node's key value is always greater than or equal to the key value of any one of the child nodes.

The minimum heap when the key value of the parent node is always less than or equal to the key value of any one of the child nodes.

Preserve the nature of the heap:

Maxheap is the most important subroutine that operates on the largest heap.

Sub-tree with I as root:

At each step of the algorithm, from A[i], a[left (i)], a[right (i)] finds the maximum value and has its subscript in Largestindex. If A[i] is the largest, then the subtree with the root of I is already the largest heap, and the program ends.

Otherwise I have the largest element in a sub-node to Exchange A[i],a[largetindex], so that I and children to meet the heap nature. The largestindex of the node after the exchange of the value of A[i], with the node as the root of the subtree is likely to violate the nature of the maximum heap, and therefore also recursively call the maxheap of the subtree, re-balance the sub-tree.

[CPP]View Plaincopy

2. To adjust a subtree with index as its root
4. N: Number of elements in the heap
6. int maxheap (int a[],int index,int n) {
8. int largestindex = index;
10. //Left Dial hand node
12. int leftindex = 2*index;
14. //Right child node
16. int rightindex = 2*index+1;
18. if (leftindex <= n && a[leftindex] > A[largestindex]) {
20. Largestindex = Leftindex;
22. }
24. if (rightindex <= n && a[rightindex] > A[largestindex]) {
26. Largestindex = Rightindex;
28. }
30. //If A[INDEX] is the largest, then the subtree with index root is already the largest heap or the child node of index has the largest element
32. //Exchange A[index],a[largetindex], so that index and children meet the heap nature
34. int temp;
36. if (largestindex! = index) {
38. //Exchange A[index],a[largetindex]
40. temp = A[index];
42. A[index] = A[largestindex];
44. A[largestindex] = temp;
46. //re-adjust the subtree with Largestindex as root
48. Maxheap (A,largestindex,n);
50. }
52. return 0;
54. }

Build heap:

We can use Maxheap to make an array a[1-n] into a maximum heap, the elements in the sub-array a[n/2+1,........ n] are leaves in the tree, so each can be seen as a heap with only one element, which satisfies the requirements of the maximum heap, without adjustment. So just resize the subtree to be the root of the element in a[n/2........1] to make it the largest heap.

[CPP]View Plaincopy

2. Build heap: Convert an array a[1-n] into a maximum heap
4. int buildmaxheap (int a[],int n) {
6. int i;
8. the elements in the//sub-array a[(N/2+1,N/2+2......N)] are all leaves in the tree
10. For (i = n/2;i >= 1;i--) {
12. //Adjust the tree with I as the root node to make it the largest heap
14. Maxheap (A,i,n);
16. }
18. return 0;
20. }

A array

16

7

3

20

17

8

Initial heap:

Bottom-up adjustment starts from the last non-leaf node:

(a) (b) (c) (d)

Each adjustment is from the parent node, the left child node, the right child node three of the largest selection of the parent node to Exchange (after the Exchange may cause the exchange of the child node does not satisfy the nature of the heap, so after each exchange to re-exchange the child node to adjust).

Heap Sort:

At the beginning, the heap sort is first constructed into a maximum heap with buildmaxheap input array a[1-n]. And because the largest element in the array is at root a[1], it can be exchanged with a[n] to achieve the final correct position.

Now, if you "remove" the node n from the heap (not really deleted, but by modifying the number of elements in the heap n), you can easily build a[1-(n-1) to the maximum heap. The original root of the child is still the largest heap, the two new exchange of the root element is likely to violate the nature of the maximum heap. Then call Maxheap to readjust. The maximum heap is constructed in a[1-(n-1). Heap sorting repeats this process, and the size of the heap is reduced from n-1 to 2. To complete the sorting function

[CPP]View Plaincopy

2. Heap Sort
4. int heapsort (int a[],int n) {
6. int temp;
8. //bulidmaxheap constructs a maximum heap for the input array
10. Buildmaxheap (A,n);
12. ////The largest element in the array at root a[1], it can be exchanged with a[n] to achieve the final correct position
14. For (int i = n;i >= 2;i--) {
16. //Exchange
18. temp = A[i];
20. A[i] = a[1];
22. A[1] = temp;
24. //a[i] has reached the correct position, removed from the heap
26. n--;
28. //re-adjust to maintain maximum heap properties
30. Maxheap (A,1,n);
32. }
34. return 0;
36. }

(a) (b) (c) (d)

(e) (f) (g)

(h) (i) (j) (k)

Red is the result of sorting;

Code:

[CPP]View Plaincopy

2. #include <stdio.h>
4. #include <stdlib.h>
8. Adjustment heap
10. int maxheap (int a[],int index,int n) {
12. int largestindex = index;
14. //Left Dial hand node
16. int leftindex = 2*index;
18. //Right child node
20. int rightindex = 2*index+1;
22. if (leftindex <= n && a[leftindex] > A[largestindex]) {
24. Largestindex = Leftindex;
26. }
28. if (rightindex <= n && a[rightindex] > A[largestindex]) {
30. Largestindex = Rightindex;
32. }
34. //If A[INDEX] is the largest, then the subtree with index root is already the largest heap or the child node of index has the largest element
36. //Exchange A[index],a[largetindex], so that index and children meet the heap nature
38. int temp;
40. if (largestindex! = index) {
42. //Exchange A[index],a[largetindex]
44. temp = A[index];
46. A[index] = A[largestindex];
48. A[largestindex] = temp;
50. //re-adjust the subtree with Largestindex as root
52. Maxheap (A,largestindex,n);
54. }
56. return 0;
58. }
64. Build heap: Convert an array a[1-n] into a maximum heap
66. int buildmaxheap (int a[],int n) {
68. int i;
70. the elements in the//sub-array a[(N/2+1,N/2+2......N)] are all leaves in the tree
72. For (i = n/2;i >= 1;i--) {
74. //Adjust the tree with I as the root node to make it the largest heap
76. Maxheap (A,i,n);
78. }
80. return 0;
82. }
86. Heap Sort
88. int heapsort (int a[],int n) {
90. int temp;
92. //bulidmaxheap constructs a maximum heap for the input array
94. Buildmaxheap (A,n);
96. ////The largest element in the array at root a[1], it can be exchanged with a[n] to achieve the final correct position
98. For (int i = n;i >= 2;i--) {
100. //Exchange
102. temp = A[i];
104. A[i] = a[1];
106. A[1] = temp;
108. //a[i] has reached the correct position, removed from the heap
110. n--;
112. //re-adjust to maintain maximum heap properties
114. Maxheap (A,1,n);
116. }
118. return 0;
120. }
122. int main () {
124. int n = 6;
126. //a[0] No, the root node of the heap is starting from 1.
128. int a[] = {0,3,17,8,7,16,20};
130. Heapsort (A,n);
132. For (int i = 1;i <= n;i++) {
134. printf ("%d", a[i]);
136. }
138. return 0;
140. }

The heap sort of "turn" algorithm