冒泡排序
算法思想:
第一轮比较:数组中从开始位置相邻数字两两比较,数字大的后移,直到最大的数字落在数组中的最后一个位置,比较次数为数组长度减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)的排序方法:快速排序、堆排序或归并排序。
快速排序是目前基于比较的内部排序中被认为是最好的方法,当待排序的关键字是随机分布时,快速排序的平均时间最短。