冒泡、选择、快速排序算法（附java实现源码）

冒泡排序：依次比较相邻的两个数，将小数放在前面，大数放在后面。具有稳定性，时间复杂度为O(n^2) 不及堆排序，快速排序O(nlogn,底数为2)。

public class BuddleSort {
	/**
	 * 依次比较相邻的两个数，将小数放在前面，大数放在后面 
	 * 冒泡排序，具有稳定性 时间复杂度为O(n^2) 不及堆排序，快速排序O(nlogn,底数为2)
	 */
	public static void main(String[] args){
		Random ran=new Random();
		int[] sort=new int[10];
		for(int i=0;i<sort.length;i++){
			sort[i]=ran.nextInt(50);
		}
		System.out.println("排序前的数组为：");
		for(int i:sort){
			System.out.print(i+" ");
		}
		System.out.println();
		buddleSort(sort);
		System.out.println("通过冒泡排序排序后的数组为：");
		for(int i:sort){
			System.out.print(i+" ");
		}
	}

	private static void buddleSort(int[] sort) {
		for(int i=1;i<sort.length;i++){
			for(int j=0;j<sort.length-i;j++){
				if(sort[j]>sort[j+1]){
					int temp = sort[j+1];
					sort[j+1] = sort[j];
					sort[j] = temp;
				}
			}
		}
	}
}

选择排序：每一趟从待排序的数组元素中选出最小（或最大）的一个元素， 顺序放在已拍好的数列的最后，直到全部待排序的数据元素排完，快速排序是不稳定的排序方法。

public class SelectSort {
	public static void main(String[] args) {
		Random ran = new Random();
		int[] sort = new int[10];
		for (int i = 0; i < sort.length; i++) {
			sort[i] = ran.nextInt(50);
		}
		System.out.println("排序前的数组为：");
		for (int n : sort) {
			System.out.print(n + " ");
		}
		System.out.println();
		selectSort(sort);
		System.out.println("通过选择排序排序后的数组为：");
		for (int n : sort) {
			System.out.print(n + " ");
		}

	}

	private static void selectSort(int[] sort) {
		for (int i = 0; i < sort.length; i++) {
			for (int j = i; j < sort.length; j++) {
				if (sort[i] > sort[j]) {
					int temp = sort[j];
					sort[j] = sort[i];
					sort[i] = temp;
				}
			}
		}
	}
}

快速排序：在要排序的数列中选取一个元素（通常选用第一个元素）作为关键元素，然后将所有比它小的元素放在它前面，所有比它大的数放在它后面。

public class QuickSort {
	@Test
	public void test() {
		int[] arrs = new int[] { 6, 2, 7, 3, 8, 9 };
		sort(arrs);

		for (int t : arrs) {
			System.out.println(t + "\t");
		}
	}

	public void sort(int[] arrs) {
		sort(arrs, 0, arrs.length - 1);
	}

	private void sort(int[] arrs, int from, int to) {
		// 如果from>=to,结束递归调用
		if (from >= to) {
			return;
		}
		// 分区操作,从from排序到to,找到基准值，并放到数字的相应位置，再返回这个位置的索引
		int p = partition(arrs, from, to);
		// 再递归对from到基准位置进行排序
		sort(arrs, from, p);
		// 再递归对基准位置+1到to位置进行排序
		sort(arrs, p + 1, to);
	}

	// 一次partition操作目标：从from到to

	private int partition(int[] arrs, int from, int to) {
		// 假设from位置的数为基准值
		int base = arrs[from];
		// 将i设定为from-1的位置
		int i = from - 1;
		// 将j设定为to+1的位置
		int j = to + 1;
		// i<j,循环
		while (i < j) {
			// 将i++从左到右，找到比base基准值大的值的位置
			i++;
			while (arrs[i] < base) {
				i++;
			}
			// 将j--从右到左，找到比base基准值小的值的位置
			j--;
			while (arrs[j] > base) {
				j--;
			}
			// 以上记住了两个下标，i中存了比基值大的值的索引，j中存了比基值小的值的索引，如果i<j则进行交换
			if (i < j) {
				int temp = arrs[j];
				arrs[j] = arrs[i];
				arrs[i] = temp;
			}
		}
		// 一直循环到i>=j,表明一次循环结束，找到了基准值的位置，将这个基准值位置返回
		return j;
	}

}