堆排序：利用大根堆
数组全部入堆，再出堆从后向前插入回数组中，数组就从小到大有序了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
public class MaxHeap<T extends Comparable<? super T>> { private T[] data; private int size; private int capacity; public MaxHeap(int capacity) { this.data = (T[]) new Comparable[capacity + 1]; size = 0; this.capacity = capacity; } public int size() { return this.size; } public boolean isEmpty() { return size == 0; } public int getCapacity() { return this.capacity; } /** * @return 查看最大根(只看不删, 与popMax对比) */ public T seekMax() { return data[1]; } public void swap(int i, int j) { if (i != j) { T temp = data[i]; data[i] = data[j]; data[j] = temp; } } public void insert(T item) { size++; data[size] = item; shiftUp(size); } /** * @return 弹出最大根(弹出意味着删除, 与seekMax对比) */ public T popMax() { swap(1, size--); shiftDown(1); return data[size + 1]; } /** * @param child 孩子节点下角标是child，父节点下角表是child/2 */ public void shiftUp(int child) { while (child > 1 && data[child].compareTo(data[child / 2]) > 0) { swap(child, child / 2); child = child / 2; } } /** * @param a data数组中某个元素的下角标 * @param b data数组中某个元素的下角标 * @return 哪个元素大就返回哪个的下角标 */ private int max(int a, int b) { if (data[a].compareTo(data[b]) < 0) {//如果data[b]大 return b;//返回b } else {//如果data[a]大 return a;//返回a } } /** * @param a data数组中某个元素的下角标 * @param b data数组中某个元素的下角标 * @param c data数组中某个元素的下角标 * @return 哪个元素大就返回哪个的下角标 */ private int max(int a, int b, int c) { int biggest = max(a, b); biggest = max(biggest, c); return biggest; } /** * @param father 父节点下角标是father,左右两个孩子节点的下角表分别是：father*2 和 father*2+1 */ public void shiftDown(int father) { while (true) { int lchild = father * 2;//左孩子 int rchild = father * 2 + 1;//右孩子 int newFather = father;//newFather即将更新，父、左、右三个结点谁大，newFather就是谁的下角标 if (lchild > size) {//如果该father结点既没有左孩子，也没有右孩子 return; } else if (rchild > size) {//如果该father结点只有左孩子，没有右孩子 newFather = max(father, lchild); } else {//如果该father结点既有左孩子，又有右孩子 newFather = max(father, lchild, rchild); } if (newFather == father) {//说明father比两个子结点都要大，表名已经是大根堆，不用继续调整了 return; } else {//否则，还需要继续调整堆，直到满足大根堆条件为止 swap(father, newFather);//值进行交换 father = newFather;//更新father的值，相当于继续调整shiftDown(newFather) } } } public static <T extends Comparable<? super T>> void sort(T[] arr) { int len = arr.length; //入堆 MaxHeap<T> maxHeap = new MaxHeap<T>(len); for (int i = 0; i < len; i++) { maxHeap.insert(arr[i]); } //出堆 for (int i = len - 1; i >= 0; i--) { arr[i] = maxHeap.popMax(); } } public static void printArr(Object[] arr) { for (Object o : arr) { System.out.print(o); System.out.print("\t"); } System.out.println(); } public static void main(String args[]) { Integer[] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6}; printArr(arr);//3 5 1 7 2 9 8 0 4 6 sort(arr); printArr(arr);//0 1 2 3 4 5 6 7 8 9 }} |
堆排序：对数组进行构造堆(最大堆)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
public class MaxHeap<T extends Comparable<? super T>> { private T[] data; private int size; private int capacity; public MaxHeap(int capacity) { this.capacity = capacity; this.size = 0; this.data = (T[]) new Comparable[capacity + 1]; } public MaxHeap(T[] arr) {//heapify,数组建堆 capacity = arr.length; data = (T[]) new Comparable[capacity + 1]; System.arraycopy(arr, 0, data, 1, arr.length); size = arr.length; for (int i = size / 2; i >= 1; i--) { shiftDown(i); } } public int size() { return this.size; } public int getCapacity() { return this.capacity; } public boolean isEmpty() { return size == 0; } public T seekMax() { return data[1]; } public void swap(int i, int j) { if (i != j) { T temp = data[i]; data[i] = data[j]; data[j] = temp; } } public void insert(T item) { size++; data[size] = item; shiftUp(size); } public T popMax() { swap(1, size--); shiftDown(1); return data[size + 1]; } public void shiftUp(int child) { while (child > 1 && data[child].compareTo(data[child / 2]) > 0) { swap(child, child / 2); child /= 2; } } /** * @param a data数组中某个元素的下角标 * @param b data数组中某个元素的下角标 * @return 哪个元素大就返回哪个的下角标 */ private int max(int a, int b) { if (data[a].compareTo(data[b]) < 0) {//如果data[b]大 return b;//返回b } else {//如果data[a]大 return a;//返回a } } /** * @param a data数组中某个元素的下角标 * @param b data数组中某个元素的下角标 * @param c data数组中某个元素的下角标 * @return 哪个元素大就返回哪个的下角标 */ private int max(int a, int b, int c) { int biggest = max(a, b); biggest = max(biggest, c); return biggest; } public void shiftDown(int father) { while (true) { int lchild = father * 2; int rchild = father * 2 + 1; int newFather = father;//这里赋不赋值无所谓，如果把下面这个return改成break,那就必须赋值了 if (lchild > size) {//如果没有左、右孩子 return; } else if (rchild > size) {//如果没有右孩子 newFather = max(father, lchild); } else {//如果有左、右孩子 newFather = max(father, lchild, rchild); } if (newFather == father) {//如果原父结点就是三者最大，则不用继续整理堆了 return; } else {//父节点不是最大，则把大的孩子交换上来，然后继续往下堆调整，直到满足大根堆为止 swap(newFather, father); father = newFather;//相当于继续shiftDown(newFather)。假如newFather原来是father的左孩子，那就相当于shiftDown(2*father) } } } public static <T extends Comparable<? super T>> void sort(T[] arr) { int len = arr.length; MaxHeap<T> maxHeap = new MaxHeap<>(arr); for (int i = len - 1; i >= 0; i--) { arr[i] = maxHeap.popMax(); } } public static void printArr(Object[] arr) { for (Object o : arr) { System.out.print(o); System.out.print("\t"); } System.out.println(); } public static void main(String args[]) { Integer[] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6}; printArr(arr);//3 5 1 7 2 9 8 0 4 6 sort(arr); printArr(arr);//0 1 2 3 4 5 6 7 8 9 }} |
以上这篇堆排序实例(Java数组实现)就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持服务器之家。
原文链接：http://www.cnblogs.com/noKing/p/7955197.html
