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

1.冒泡排序算法

/* 冒泡排序 */
	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;
	}

2.插入排序算法

	/* 插入排序 */
	/*
	 * 基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置（从后向前找到合适位置后）
	 * 直到全部插入排序完为止。(类似于扑克牌抓牌)
	 */
	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;
	}

3选择排序算法
	/* 简单选择排序 */
	/*
	 * 基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
	 * 然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
	 */
	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;

	}

4.快速排序算法
	/* 快速排序 */
	/*
	 * 基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素, 通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,
	 * 此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。
	 * 
	 * 一趟快速排序的算法是：
        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)

稳定性：

冒泡：稳定
插入：稳定
选择：不稳定
快排：不稳定