Java实现经典排序算法及复杂度稳定性分析

/* 冒泡排序 */
public static int[] bubbleSort(int[] arry) {
for (int i = 0; i < arry.length; i++) {
for (int j = i; j < arry.length - i - 1; j++) {
if (arry[j] > arry[j + 1]) {
int temp = arry[j];
arry[j] = arry[j + 1];// 交换顺序，大的在后，小的在前
arry[j + 1] = temp;
}
}
}
return arry;
}

/* 插入排序 */
/*
* 基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置（从后向前找到合适位置后）
* 直到全部插入排序完为止。(类似于扑克牌抓牌)
*/
public static int[] insertSort(int[] arry) {
// 从数组第二位开始，第一位为初始排好的顺序
for (int i = 1; i < arry.length; i++) {
int temp = arry[i];// 保存待插入的数值
int j = i - 1;// 当前数值的前一位数组角标
for (j = i - 1; j >= 0; j--) {
if (arry[j] > temp) {
arry[j + 1] = arry[j];// 将前一位数值移动一位（内部循环比较找到要最后要插入的位置）
} else {
break;
}
}
arry[j + 1] = temp;// 将待插入的数值插入合适的位置
}
return arry;
}

/* 简单选择排序 */
/*
* 基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
* 然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
*/
public static int[] choiceSort(int[] arry) {
for (int i = 0; i < arry.length; i++) {
int low = i;
for (int j = i + 1; j < arry.length; j++) {
if (arry[j] < arry[low]) {
low = j;// 寻找最小数值位置
}
}
// 将当前第一个元素与它后面序列中的最小的一个 元素交换，也就是将最小的元素放在最前端
int temp = arry[i];
arry[i] = arry[low];
arry[low] = temp;
}
return arry;

}

/* 快速排序 */
/*
* 基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素, 通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,
* 此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。
*
* 一趟快速排序的算法是：
1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；
4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；
5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]
不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行
交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。
*/
public static int[] quickSort(int[] arry, int low, int high) {
if (low < high) {
int middle = getMiddle(arry, low, high);
quickSort(arry, 0, middle - 1);//递归快排左边这个部分
quickSort(arry, middle + 1, high);//递归快排右边这个部分
}
return arry;

}

private static int getMiddle(int[] arry, int low, int high) {
int temp = arry[low];// 基准元素
while (low < high) {
while (low < high && arry[high] >= temp) {
high--;//从最右边往左找小于基准的元素
}
arry[low] = arry[high];//交换位置，小的在基准元素左边
while (low < high && arry[low] <= temp) {
low++;//从基准元素的右边找大于它的元素
}
arry[high] = arry[low];//交换位置，大的在基准元素右边
}
//当low == high，完成一趟快速排序
arry[low] = temp;
return low;
}

平均时间复杂度比较：

冒泡：O(n^2)

插入：O(n^2)

选择：O(n^2)

快排：O(nlgn)

稳定性：

冒泡：稳定

插入：稳定

选择：不稳定
快排：不稳定

转载自：http://blog.csdn.net/u013812939/article/details/46739923点击打开链接