八大排序算法Java实现
JDK7的Collections.sort()的算法是TimSort, 适应性的归并排序, 比较晦涩难懂, 这里没有实现
public class mySort {
// 冒泡排序
public static void myBubbleSort(int[] array) {
int lastExchange = array.length - 1; //记录最后交换位置, 避免重复比较
for (int i = lastExchange - 1; i >= 0; --i) {
for (int j = 0; j <= i; ++j) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
lastExchange = j; //特性:最后交互位置后的元素已经有序
}
}
}
}
// 插入排序
public static void myInsertSort(int[] array) {
for (int i = 1; i <= array.length - 1; ++i) {
int temp = array[i];
int j = 0; // 给值移位并寻找插入点
for (j = i - 1; j >= 0 && array[j] > temp; --j) {
array[j + 1] = array[j];
}
array[j + 1] = temp;
}
}
// 选择排序
public static void mySelectSort(int[] array) {
for (int i = 0; i < array.length - 1; ++i) {
int minIndex = i;
// 每次选出一极值
for (int j = i + 1; j <= array.length - 1; ++j) {
if (array[j] < array[minIndex]) {
minIndex = j;
}
}
// 极值归位
if (minIndex != i) {
int temp = array[minIndex];
array[minIndex] = array[i];
array[i] = temp;
}
}
}
// 希尔排序
public static void myShellSort(int[] array) {
int gap = 5;
while (gap != 0) {
//不必刻意分组, 组1->组2->组1->组2...轮流处理
for (int j = gap; j <= array.length - 1; ++j) {
int temp = array[j];
int k = 0;
for (k = j - gap; k >= 0 && array[k] > temp; k -= gap) {
array[k + gap] = array[k];
}
array[k + gap] = temp;
}
gap /= 2; //重新分组
}
}
// 快速排序
public static void myQuickSort(int[] array) {
myQuickSortCore(array, 0, array.length - 1);
}
private static void myQuickSortCore(int[] array, int left, int right) {
if (left >= right) { //递归出口
return;
}
int mLeft = left;
int mRight = right;
int base = array[mLeft]; //第一个元素作为基准, left空位可占
while(mLeft != mRight) {
while (mRight > mLeft && array[mRight] >= base) {
--mRight;
}
array[mLeft] = array[mRight]; //right可覆盖
while (mRight > mLeft && array[mLeft] <= base) {
++mLeft;
}
array[mRight] = array[mLeft];
}
array[mRight] = base; //基准元素归位, l=r
myQuickSortCore(array, left, mLeft - 1); //递归基准以左
myQuickSortCore(array, mRight + 1 , right); //递归基准以右
}
// 归并排序
public static void myMergeSort(int[] array) {
// 每个分组中有两个来自上层迭代的有序组, gap为有序组长度, 2 * gap为分组长度
for (int gap = 1; gap < array.length; gap *= 2) {
int i = 0; // array下标
// 分组并内部排序
while (i + 2 * gap - 1 < array.length) {
mergePiece(array, i, i + gap - 1, i + 2 * gap - 1);
i += 2 * gap;
}
// 分组剩余部分排序, 只有超过一个gap才有内部排序的意义
if (i + gap - 1 < array.length) {
mergePiece(array, i, i + gap - 1, array.length - 1);
}
}
}
// 将array中有序的两段piecewise1 和 piecewise2 合并成整体有序
public static void mergePiece(int[] array, int head, int mid, int tail) {
int i = head; // piecewise1下标 [head, mid]
int j = mid + 1; // piecewise2下标 [mid + 1, tail]
// 临时数组, 保存结果
int[] arrayTemp = new int[tail - head + 1]; // combine
int k = 0; // combine下标
while (i <= mid && j <= tail) {
if (array[i] <= array[j]) {
arrayTemp[k] = array[i];
++i;
++k;
} else {
arrayTemp[k] = array[j];
++j;
++k;
}
}
// 复制多余部分 piecewise1
while (i <= mid) {
arrayTemp[k] = array[i];
++i;
++k;
}
// 复制多余部分 piecewise2
while (j <= tail) {
arrayTemp[k] = array[j];
++j;
++k;
}
// 结果复制到原始数组
k = 0;
i = head; // 重置下标, i piecewise1 + piecewise2
while (i <= tail) {
array[i] = arrayTemp[k];
++i;
++k;
}
}
// 堆排序
public static void myHeapSort(int[] array) {
// 调整堆->大顶堆
for (int i = array.length / 2 - 1; i >= 0; --i) { // 从最后非叶子节点开始
adjustHeap(array, i, array.length);
}
// 调整堆->交换堆顶/末位元素
for (int j = array.length - 1; j > 0; --j) {
int temp = array[0];
array[0] = array[j];
array[j] = temp;
adjustHeap(array, 0, j); // 只需调整堆顶父节点
}
}
// 调整为大顶堆分布, node为父节点下标, adjustLen为涉及调整的长度(为排序使用)
private static void adjustHeap(int[] array, int node, int adjustLen) {
int temp = array[node]; // 拿出node形成可占空位
for (int i = node * 2 + 1; i < adjustLen; i = node * 2 + 1) {
if (i + 1 < adjustLen && array[i] < array[i + 1]) {
++i; // 得到最大子节点
}
if (array[i] > temp) {
array[node] = array[i];
node = i; // 为下一层迭代更新父节点node, 最后为叶子
} else {
break;
}
}
array[node] = temp;
}
// 基数排序
public static void myRadixSort(int[] array) {
int d = maxBit(array);
int dec = 1; //进制迭代
final int R = 10; //桶个数
int[] tempArray = new int[array.length]; //临时数组, 代替桶存储数组, 代价是需记录下标/数量来分割桶
int[] bucketCapacity = new int[R]; //桶计数
for (int i = 1; i <= d; ++i) {
for (int j = 0; j < R; ++j) {
bucketCapacity[j] = 0; //清空桶容量
}
//计数1
for (int j = 0; j < array.length; ++j) {
int k = array[j] / dec % R;
++bucketCapacity[k];
}
//计数2 变累计, 为分割
for (int j = 1; j < R; ++j) {
bucketCapacity[j] = bucketCapacity[j - 1] + bucketCapacity[j];
}
// 存储进桶
for (int j = array.length - 1; j >= 0; --j) {
int k = array[j] / dec % R;
tempArray[bucketCapacity[k] - 1] = array[j];
--bucketCapacity[k];
}
// 写出
for(int j = 0; j < array.length; ++j) {
array[j] = tempArray[j];
}
// 下一位
dec *= 10;
}
}
//求数组元素的最大位数
private static int maxBit(int[] array) {
int bit = 1;
int dec = 10;
for (int i = 0; i < array.length; ++i) {
while (array[i] >= dec) {
++bit;
dec *= 10;
}
}
return bit;
}
}
