排序算法(二) -- 冒泡、选择、插入排序

1.冒泡排序

1.1 基本介绍

冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。
优化：
因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志 flag 判断元素是否进行过交换。从而减少不必要的比较。(这里说的优化，可以在冒泡排序写好后，在进行)

1.2 演示冒泡过程的例子(图解)

小结冒泡排序规则
(1) 一共进行 数组的大小-1 次 大的循环
(2)每一趟排序的次数在逐渐的减少
(3) 如果我们发现在某趟排序中，没有发生一次交换， 可以提前结束冒泡排序(这个就是优化)

1.3 冒泡排序代码实现

	public static void bubbleSort(int[] arr) {
		// 冒泡排序时间复杂度为O(n^2)
		int temp = 0;
		boolean flag = false;// 标识变量，标识是否进行过交换
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1 - i; j++) {
				// 如果前面的数比后面的数大则交换
				if (arr[j] > arr[j + 1]) {
					flag = true;
					temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
//			System.out.println("第" + (i + 1) + "趟排序后的数组");
//			System.out.println(Arrays.toString(arr));
			if (!flag) {// 在一次排序中，一次交换都没有发生过
				break;
			} else {
				flag = false;// 重置flag，进行下次判断
			}
		}
	}

1.3 冒泡排序性能分析

冒泡排序的时间复杂度为O(n^2),为了测试冒泡排序的速度，我们给定80000个数据测试。

	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		int arr[] = { 3, 9, -1, 10, 20 };
//		System.out.println("排序前的数组为：");
//		System.out.println(Arrays.toString(arr));
		//测试一下冒泡排序的速度O(n^2),给80000个数据测试
		//创建要给80000个随机的数组
		int[] arr = new int[8];
		for(int i = 0 ; i < 8; i++){
			arr[i] = (int)(Math.random() * 80000);//生成一个[0,80000]之间的数
		}
		Date date1 = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String date1Str = simpleDateFormat.format(date1);
		System.out.println("排序前的时间是:"+date1Str);
		bubbleSort(arr);
	//	System.out.println("排序后的数组为：");
	//	System.out.println(Arrays.toString(arr));
		Date date2 = new Date();
		String date2Str = simpleDateFormat.format(date2);
		System.out.println("排序后的时间是:"+date2Str);
	}

执行结果如下：可以看出80000条数据的测试结果为10s左右

2. 选择排序

2.1 基本介绍

选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到排序的目的。

2.2 选择排序思想:

选择排序（select sorting）也是一种简单的排序方法。它的基本思想是：第一次从 arr[0]~arr[n-1]中选取最小值， 与 arr[0]交换，第二次从 arr[1]~arr[n-1]中选取最小值，与 arr[1]交换，第三次从 arr[2]~arr[n-1]中选取最小值，与 arr[2] 交换，…，第 i 次从 arr[i-1]~arr[n-1]中选取最小值，与 arr[i-1]交换，…, 第 n-1 次从 arr[n-2]~arr[n-1]中选取最小值， 与 arr[n-2]交换，总共通过 n-1 次，得到一个按排序码从小到大排列的有序序列。

2.3 演示选择排序过程的例子(图解)

2.4 选择排序代码实现

public static void selectSort(int[] arr) {
		for(int i = 0 ; i < arr.length - 1 ; i++){
			int minIndex = i;
			int min = arr[i];
			for (int j = i + 1; j < arr.length; j++) {
				if (min > arr[j]) {
					min = arr[j];
					minIndex = j;
				}
			}
			if(minIndex != i){
				arr[minIndex] = arr[i];
				arr[i] = min;
			}
		/*	System.out.println("第"+(i+1)+"轮后~~");
			System.out.println(Arrays.toString(arr));*/
		}
}

2.4 选择排序性能分析

同样选择排序的时间复杂度为O(n^2),为了测试选择排序的速度，我们给定80000个数据测试。

public static void main(String[] args) {
		// TODO Auto-generated method stub
		//int[] arr = {101,34,119,1};
		int[] arr = new int[80000];
		for(int i = 0 ; i < 80000; i++){
			arr[i] = (int)(Math.random() * 80000);//生成一个[0,80000]之间的数
		}
		Date date1 = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String date1Str = simpleDateFormat.format(date1);
		System.out.println("排序前的时间是:"+date1Str);
		//System.out.println("排序前：");
		//System.out.println(Arrays.toString(arr));
		selectSort(arr);
		Date date2 = new Date();
		String date2Str = simpleDateFormat.format(date2);
		System.out.println("排序后的时间是:"+date2Str);

	}

执行结果：从机器的测试结果来看，选择排序要比冒泡排序快

3. 插入排序

3.1 插入排序法介绍:

插入式排序属于内部排序法，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。

3.2 插入排序法思想:

插入排序（Insertion Sorting）的基本思想是：把 n 个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有 n-1 个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。

3.3 插入排序的图解：

3.4 插入排序的代码实现

	//插入排序
	public static void insertSort(int[] arr){
		
		int insertVal = 0;
		int insertIndex = 0;
		// 使用for循环简化代码
		for (int i = 1; i < arr.length; i++) {
			insertVal = arr[i];
			insertIndex = i - 1; // 即arr[1]的前面这个数的下标

			// 给insertVal 找到插入的位置
			// 1.insertIndx >= 0保证在给insertVal 找位置时不越界
			// 2.insertVal < arr[insertIndex] 待插入的数，还有没找到插入的位置
			while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
				arr[insertIndex + 1] = arr[insertIndex];
				insertIndex--;
			}
			// 当退出while循环时说明插入位置找到了，insertIndex + 1
			if (insertIndex + 1 != i) {
				arr[insertIndex + 1] = insertVal;
			}

			
			// System.out.println("第" + i + "轮插入");
		    // System.out.println(Arrays.toString(arr));
			 
		}
	}

3.5 插入排序的性能测试

同样插入排序的时间复杂度为O(n^2),为了测试插入排序的速度，我们给定80000个数据测试。

public static void main(String[] args) {
		// TODO Auto-generated method stub

		// int[] arr = {101,34,119,1};
		// 创建要给80000个随机的数组
		int[] arr = new int[80000];
		for (int i = 0; i < 80000; i++) {
			arr[i] = (int) (Math.random() * 80000);// 生成一个[0,80000]之间的数
		}
		Date date1 = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String date1Str = simpleDateFormat.format(date1);
		System.out.println("排序前的时间是:" + date1Str);
		insertSort(arr);
		Date date2 = new Date();
		String date2Str = simpleDateFormat.format(date2);
		System.out.println("排序后的时间是:"+date2Str);
	}

执行结果如下：