Java实现基本排序算法

稳定排序算法性能比较

冒泡排序代码：

/**
* 冒泡排序
*
* @param arr
* @return
*/
public int[] bubbleSort(int[] arr) {
int temp;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
}

直接插入排序代码：

/**
* 直接插入排序
*
* @param arr
* @return
*/
public int[] insertSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
if (arr[i] < arr[i - 1]) {
int temp = arr[i];
int j = i;
while (j > 0 && arr[j - 1] > temp) {
arr[j] = arr[j - 1];
j--;
}
arr[j] = temp;
}
}
return arr;
}

基数排序代码：

/**
* 基数排序，又称桶排序
*
* @param arr
* @return
*/
public int[] radixSort(int[] arr, int d) {
int k = 0;
int n = 1;
int m = 1; // 控制键值排序依据在哪一位
int[][] temp = new int[10][arr.length]; // 数组的第一维表示可能的余数0-9
int[] order = new int[10]; // 数组orderp[i]用来表示该位是i的数的个数
while (m <= d) {
for (int i = 0; i < arr.length; i++) {
int lsd = ((arr[i] / n) % 10);
temp[lsd][order[lsd]] = arr[i];
order[lsd]++;
}
for (int i = 0; i < 10; i++) {
if (order[i] != 0)
for (int j = 0; j < order[i]; j++) {
arr[k] = temp[i][j];
k++;
}
order[i] = 0;
}
n *= 10;
k = 0;
m++;
}
return arr;
}

不稳定排序算法性能比较

选择排序代码：

/**
* 选择排序
*
* @param arr
* @return
*/
public int[] selectSort(int[] arr) {
int temp;
for (int i = 0; i < arr.length; i++) {
int minus = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[i])
minus = j;
}
if (minus != i) {
temp = arr[i];
arr[i] = arr[minus];
arr[minus] = temp;
}
}
return arr;
}

希尔排序代码：

/**
* 希尔排序
*/
public int[] shllSort(int[] arr) {
int dk = arr.length / 2;
while (dk >= 1) {
for (int i = 0; i < dk; i++) {
for (int j = i + dk; j < arr.length; j = j + dk) {
if (arr[j] < arr[j - dk]) {
int temp = arr[j];
int k = j;
while (k > i && arr[k - dk] > temp) {
arr[k] = arr[k - dk];
k = k - dk;
}
arr[k] = temp;
}
}
}
dk = dk / 2;
}

return arr;
}
}

快速排序代码：

/**
* 快速排序
*
* @param arr
*            待排序数组
* @param left
*            待排序数组左边界
* @param right
*            待排序数组右边界
* @return
*/
public int[] quickSort(int[] arr, int left, int right) {
int temp;
if (left < right) {
int s = arr[left];
int i = left;
int j = right;
while (true) {
while (i + 1 < arr.length && arr[++i] < s)
;
while (j - 1 > -1 && arr[--j] > s)
;
if (i >= j)
break;
else {
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
arr[left] = arr[j];
arr[j] = s;
quickSort(arr, left, j - 1);
quickSort(arr, j + 1, right);
}
return arr;
}

/**
* 快速排序第二种实现方式
*
* @param arr
*            待排序数组
* @param left
*            待排序数组左边界
* @param right
*            待排序数组右边界
* @return
*/
public int[] quickSort2(int[] arr, int left, int right) {
if (left < right) {
int key = arr[left];
int low = left;
int high = right;
while (low < high) {
while (high > low && arr[high] >= key)
high--;
arr[low] = arr[high];
while (low < high && arr[low] <= key)
low++;
arr[high] = arr[low];
}
arr[low] = key;
quickSort2(arr, left, low - 1);
quickSort2(arr, low + 1, right);
}
return arr;
}