Write the algorithm. Sort. heapsort by yourself

Heap Sort Algorithm

Heap-Sort uses Max heap data structure to sort a sequence. The steps are:

• We need construct a max heap in place firstly, so that we can make sure that the bigest value locates on the first position of the heap.
• Swap the top value with the last value of the sequence, and shrink the size to nSize-1, and reconstruct the max heap.
• Swap loopsly and the sequence will be sorted.

The key issue is how to present a max heap data structure by an array.

 

1. # Define left_child_index (idx) (idx * 2 + 1)
2. # Define right_child_index (idx) (idx * 2 + 2)
3. # Define parent_index (idx) (idx-1)/2
5. /*
6. Given a max-heap, if we changed a value at idx, We shoshould make sure
7. That all its children are not bigger than it.
8. */
9. Void max_heapify (const int idx, int arr [], const int nsize)
10. {
11. Int ncur = idx;
12. Int nleft = left_child_index (ncur );
13. Int nright = right_child_index (ncur );
15. If (nright <nSize-1)
16. {
17. If (ARR [ncur] <arr [nright])
18. {
19. STD: swap (ARR [ncur], arr [nright]);
20. Max_heapify (nright, arr, nsize );
21. }
22. }
24. If (nleft <nSize-1)
25. {
26. If (ARR [ncur] <arr [nleft])
27. {
28. STD: swap (ARR [ncur], arr [nleft]);
29. Max_heapify (nleft, arr, nsize );
30. }
31. }
34. }
36. /*
37. A Non Complete Binary Tree has (nsize + 1)/2 children
38. */
39. Void build_max_heap (INT arr [], const int nsize)
40. {
41. Int ncount = nsize-(nsize + 1)/2;
42. For (INT I = 0; I <ncount; ++ I)
43. {
44. Max_heapify (I, arr, nsize );
45. }
46. }
48. /*
49. Build a max heap firstly, so the first one is the biggest one
50. Swap with the last one, rebuild the max heap, but ignoring the last one
51. */
52. Void sortheap: Sort (INT arr [], const int nsize)
53. {
54. Alog: Print (_ T ("# Heap Sort :"));
55. Alog: Print (ARR, nsize );
57. Build_max_heap (ARR, nsize );
58. Alog: Print (ARR, nsize );
59. For (INT I = nSize-1; I> 1; -- I)
60. {
61. STD: swap (ARR [0], arr [I]);
62. Max_heapify (0, arr, I );
63. Alog: Print (ARR, nsize );
64. }
65. }
67. Void sortheap: Test ()
68. {
69. Int arr [] = {2, 9, 3, 7, 8, 6, 4, 5, 0, 1 };
70. Const int nsize = sizeof (ARR)/sizeof (INT );
71. Sortheap: Sort (ARR, nsize );
72. }

 

The test result:

 

# Heap Sort:

2 9 3 7 8 6 4 5 0 1

======================
9 8 6 7 3 4 2 5 0 1
8 7 4 6 3 2 1 5 0 9
7 6 2 4 3 1 0 5 8 9
6 5 2 4 3 1 0 7 8 9
5 4 0 3 2 1 6 7 8 9
4 3 0 1 2 5 6 7 8 9
3 2 0 1 4 5 6 7 8 9
2 1 0 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9