Java and Algorithm (8)-Heap ordering

A heap is a special complete binary tree, which is characterized by that all parent nodes are smaller than child nodes, or that all parent nodes are larger than byte points. The first is called the minimum heap, and the latter is called the maximum heap.

For example, the following two:

So what's the effect of this feature? Since the title is a heap sort, it can certainly be used for sorting. Want to sort by heap first to create a heap, if the 4 3 6 2 7 1 5 of these seven numbers are ordered from small to large, you need to create a maximum heap with these seven numbers, to see the code:

[Java]View PlainCopyprint?

2. Public class Heapsort {
6. private int[] numbers;
8. private int length;
12. Public Heapsort (int[] numbers) {
14. this.numbers = numbers;
16. this.length = numbers.length;
18. }
22. /** 
24. * Adjust binary tree
26. * If the parent node number is x, then the number of the left Dial hand node is 2x and the right child node number is 2x+1
28. * The node number starts at 1, and the index in the corresponding array is number-1
30. * @param nodeId node number, starting from 1
32. */
34. public void adjust (int nodeId) {
36. int swapid;
38. int flag = 0; //Do you need to continue to adjust downwards
40. While (NodeId * 2 <= this.length && flag = = 0) {
42. //First determine the relationship between it and the left child node and use the Swapid to record the node number with a smaller value (the maximum heap is a larger record)
44. int index = nodeId- 1; the index of the number in the array of the//node corresponding
46. int leftchild = nodeId * 2- 1; the index of the number in the array of the///left Dial hand node
48. int rightchild = nodeId * 2; //Right child node corresponding to the index of the number in the array
50. if (Numbers[index] < Numbers[leftchild]) {
52. Swapid = NodeId * 2;
54. } Else {
56. Swapid = nodeId;
58. }
60. //If there is a right child node, then compare with right child node
62. if (nodeId * 2 + 1 <= this.length) {
64. if (Numbers[swapid- 1] < Numbers[rightchild])
66. Swapid = NodeId * 2 + 1;
68. }
70. //If the minimum node number is not self-explanatory, there is a smaller child node than the parent node
72. if (swapid! = nodeId) {
74. Swap (swapid, nodeId);
76. NodeId = Swapid;
78. } Else {
80. flag = 1;
82. }
84. }
86. }
90. /** 
92. * Exchange values for two nodes
94. * @param nodeId1
96. * @param nodeId2
98. */
100. public void swap (int nodeId1, int nodeId2) {
102. int t = numbers[nodeid1- 1];
104. NUMBERS[NODEID1- 1] = Numbers[nodeid2- 1];
106. Numbers[nodeid2- 1] = t;
108. }
112. /** 
114. * Create maximum heap
116. */
118. public void Createmaxheap () {
120. //From the last non-leaf node to the first node, in turn, upward adjustment
122. For (int i = this.length/ 2; I >= 1; i--) {
124. adjust (i);
126. }
128. }
132. public static void Main (string[] args) {
134. int[] numbers = new int[] { 4, 3, 6, 2, 7, 1, 5};
136. For (int x = 0; x < numbers.length; × x + +) {
138. System.out.print (Numbers[x] + "");
140. }
142. System.out.println ();
144. Heapsort heap = new Heapsort (numbers);
146. Heap.createmaxheap ();
148. }
150. }

For this example, the series, from THIS.LENGTH/2 to 1, performed a total of round loops.

First round:

Second round:

Third round:

After the adjustment is complete, the current two-fork tree already conforms to the maximum heap characteristics and can be used to sort from small to large. The principle of heap sorting is to swap the number of the top and last node of the heap, that is, put the largest number at the end of the array, and then re-perform the adjustment process with the number of first n-1 except the maximum number to conform to the maximum heap characteristics. Repeat the process until only one number is left in the heap.

[Java]View PlainCopyprint?

2. Public void Sort () {
4. While (this.length > 1) {
6. Swap (1, this.length);
8. this.length--;
10. Adjust (1);
12. }
14. For (int x = 0; x < numbers.length; × x + +) {
16. System.out.print (Numbers[x] + "");
18. }
20. }

The time complexity of heap sequencing is the same as the average time complexity for fast sorting, which is O (Nlogn).

Java and Algorithm (8)-Heap ordering