冒泡排序、选择排序、插入排序

冒泡排序

算法思想：

第一轮比较：数组中从开始位置相邻数字两两比较，数字大的后移，直到最大的数字落在数组中的最后一个位置，比较次数为数组长度减1；

第二轮比较：数组中从开始位置相邻数字两两比较，数字大的后移，直到最大的数字落在数组中的倒数第二位置，比较次数为数组长度减2；

......

 依次类推，直到数组排序完成，共进行数组长度减1轮比较。

    public void bubbleSort(int[] arr) {
		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]) {
					swap(arr, j, j+1);
				}
			}
		}
    
    //交换操作
    public void swap(int[] arr, int a, int b) {
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;

若在某一次排序中没有发现位置的交换，则说明待排序的无序区中所有元素都满足已排序要求。因此，冒泡排序过程可在此轮排序后终止。

为此，对冒泡排序算法提出改进，引入一个布尔变量exchange，在每次排序开始前，先将其置为false。若排序过程中发生了交换，则将其置为true。每轮排序结束时检查exchange，若没有发生过交换，则终止算法。

改进代码如下：

    public void bubbleSort(int[] arr) {
		for(int i = 0; i < arr.length-1; i++) {
			boolean exchange = false;    //定义exchange，标记是否发生了交换
			for(int j = 0; j < arr.length-1-i; j++) {
				if(arr[j] > arr[j+1]) {
					swap(arr, j, j+1);
					exchange = true;    //发生了交换，exchange置为true
				}
			}
			if(!exchange) {    //本轮排序没有发生交换，提前终止算法
				return;
			}
		}
	}
    
    //交换操作
    public void swap(int[] arr, int a, int b) {
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;

时间、空间复杂度

时间复杂度：

最好的情况，要排序的数组为正序，共进行一轮排序，进行（n-1）次比较，时间复杂度为O（n）；

最坏的情况，要排序的数组为反序，共进行（n-1）轮排序，每轮排序进行（n-i）次比较，每一次比较进行3次交换，3n*（n-1）/2，时间复杂度为O（n^2）。

平均时间复杂度为O（n^2）。

空间复杂度：

因为只用了一个中间变量缓存数据，故空间复杂度为O（1）。

 

选择排序

算法思想：

第一轮比较：数组中第一个数字依次与后面的数字比较，若比第一个数字小，互换位置，直到最小的数字落在数组中的第一位置，比较次数为数组长度减1；

第二轮比较：数组中第二个数字依次与后面的数字比较，若比第二个数字小，互换位置，直到最小的数字落在数组中的第二位置，比较次数为数组长度减2；

......

 依次类推，直到数组排序完成，共进行数组长度减1轮比较。

    public void selectSort(int[] arr) {
		for(int i = 0; i < arr.length-1; i++) {
			for(int j = i+1; j < arr.length; j++) {
				if(arr[i] > arr[j])
					swap(arr, i, j);
			}
		}
	}

    //交换操作
    public void swap(int[] arr, int a, int b) {
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
    }

时间、空间复杂度

同冒泡排序。

 

插入排序

算法思想：

1.从第一个元素开始，该元素可以认为已经被排序；

2.取出下一个元素，在已经排序的元素序列中从后向前扫描；

3.将取出的新元素与已排序的元素进行比较（从后往前），若大于，则与前一个元素比较；

4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；

5.将新元素插入到到该位置中；

6.重复步骤2，直到算法结束。

    public void insertSort(int[] arr) {
		for(int i = 0; i < arr.length - 1; i++) {
			for(int j = i+1; j > 0; j--) {
				if(arr[j] < arr[j - 1]) {
					swap(arr, j, j - 1);
				}
			}
		}
	}

    //交换操作
    public void swap(int[] arr, int a, int b) {
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
    }

时间、空间复杂度

时间复杂度：

最好的情况，要排序的数组为正序，共进行（n-1）轮排序，每轮排序进行1次比较，时间复杂度为O（n）；

最坏的情况，要排序的数组为反序，共进行（n-1）轮排序，每轮排序进行（n-i）次比较，每一次比较进行3次交换，3n*（n-1）/2，时间复杂度为O（n^2）。

平均时间复杂度为O（n^2）。

空间复杂度：

因为只用了一个中间变量缓存数据，故空间复杂度为O（1）。

 

排序方法比较

冒泡排序：时间复杂度为O(n^2)，空间复杂度为O(1)，排序稳定；

选择排序：时间复杂度为O(n^2)，空间复杂度为O(1)，排序不稳定；

插入排序：时间复杂度为O(n^2)，空间复杂度为O(1)，排序稳定；

稳定性是指如果存在多个具有相同排序码的记录，经过排序后，这些记录的相对次序仍然保持不变，则这种排序算法称为稳定的。

 

应用场景

1)若n较小(如n≤50)，可采用插入或选择排序。 当记录规模较小时，插入排序较好；否则因为选择排序移动的记录数少于插人排序，应选选择排序为宜。

 (2)若文件初始状态基本有序(指正序)，则应选用插人、冒泡或随机的快速排序为宜； 

(3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。 

快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短。