1.冒泡排序
public static void sort(int[] array) {
// 无序数列边界,其往后的都是有序的
int lastExchangeIndex = 0;
int sortBorder = array.length - 1;
for (int i = 0; i < array.length; i++) {
// 有序标志
boolean isSorted = true;
for (int j = 0; j < sortBorder; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
lastExchangeIndex = j;
isSorted = false;
}
}
sortBorder = lastExchangeIndex;
if (isSorted) {
break;
}
}
}
2.快速排序
public static void sort(int[] array, int left, int right) {
if (left >= right) {
return;
}
int l = left;
int r = right;
int base = array[left];
while (l != r) {
while (array[r] >= base && l < r) {
r--;
}
while (array[l] < base && l < r) {
l++;
}
if (l < r) {
int temp = array[l];
array[l] = array[r];
array[r] = temp;
}
}
array[left] = array[l];
array[l] = base;
sort(array, left, l - 1);
sort(array, l + 1, right);
}
3.堆排序
public static void sort(int[] array) {
// 先将数组构造成堆
for (int i = array.length - 2 / 2; i >= 0; i--) {
downAdjust(array, i, array.length);
}
// 循环删除堆顶元素,移动到集合尾部,调整产生新的堆顶
for (int i = array.length - 1; i > 0; i--) {
int temp = array[i];
array[i] = array[0];
array[0] = temp;
downAdjust(array, 0, i);
}
}
public static void downAdjust(int[] array, int parent, int length) {
int temp = array[parent];
int child = 2 * parent + 1;
while (child < length) {
if (child + 1 < length && array[child + 1] > array[child]) {
child++;
}
if (temp >= array[child]) {
break;
}
// 父节点小于子结点
array[parent] = array[child];
parent = child;
child = 2 * child + 1;
}
array[parent] = temp;
}