冒泡排序
- 思想:冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
- 代码实现
public static void BubbleSort(int[] array){
System.out.println("这里是冒泡排序");
//i代表第几轮
for(int i=1;i< (array.length-1); i++){
//交换标志位,false意味着未交换 冒泡排序结束, 跳出循环
boolean flag = true;
//每一轮冒泡出一个最大值,交换到最后一位,并作为已排序序列,所以-i
for(int j=0; j<(array.length-i); j++){
if( array[j] > array[j+1]){
int temp = array[j+1];
array[j+1] = array[j];
array[j] = temp;
flag = false;
}
}
if(flag){
break;
}
System.out.println("第"+ i +"轮排序后:");
display(array);
}
}
- 冒泡排序性能分析:假设参与比较的数组元素个数为 N,则第一轮排序有 N-1 次比较,第二轮有 N-2 次,如此类推,这种序列的求和公式为:
(N-1)+(N-2)+...+1 = N*(N-1)/2
当 N 的值很大时,算法比较次数约为 N2/2次比较,忽略减1。
交换和比较次数都和N2 成正比。由于常数不算大 O 表示法中,忽略 2 和 4,那么冒泡排序运行都需要 O(N2) 时间级别。
冒泡排序最差情况:每次都需要交换比较,是O(n2),冒泡排序最好情况:不需要交换,只是发生了(n-1)次比较,是O(n)
其实无论何时,只要看见一个循环嵌套在另一个循环中,我们都可以怀疑这个算法的运行时间为 O(N2)级,外层循环执行 N 次,内层循环对每一次外层循环都执行N次(或者几分之N次)。这就意味着大约需要执行N2次某个基本操作。
选择排序
- 思想: 选择排序是每一次从待排序的数据元素中选出最小的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。
- 代码实现
public static void ChoiceSort(int[] array){
System.out.println("这里是选择排序");
// 当前待排序元素起始位置为i
for( int i = 0; i < array.length-1; i++ ){
int min = i;
//从待排序元素中找出一个最小的
for( int j = i; j < array.length-1; j++ ){
//
if( array[j] < array[min]){
//位置记录在min中
min = j;
}
}
//如果最小值不是当前待排元素起始位置,那么就交换
if( min!=i){
int temp = array[i];
array[i] = array[min];
array[min] = temp;
}
System.out.println("第"+ i +"轮排序后:");
display(array);
}
}
- 选择排序性能分析:选择排序和冒泡排序执行了相同次数的比较:N*(N-1)/2,但是至多只进行了N次交换。
当 N 值很大时,比较次数是主要的,所以和冒泡排序一样,用大O表示是O(N2) 时间级别。但是由于选择排序交换的次数少,所以选择排序无疑是比冒泡排序快的。当 N 值较小时,如果交换时间比选择时间大的多,那么选择排序是相当快的。
以上两种对比:选择排序时间稳定,均为O(n2)级别,交换次数少,最多(N-1)次;冒泡排序时间浮动大,如果为有序数列,只需比较(n-1)次,不需交换,选择排序仍需要O(n2)级别的比较,也不需交换
插入排序
- 思想:从待排序序列中拿出一个数插入到已排序的序列的正确位置之中中
- 代码实现:
public static void InsertSort(int[] array){
//待排序的那位元素
for(int i = 1; i < (array.length-1); i++ ){
int j = 0;
//记录该元素
int temp = array[i];
//找到待排序元素array[i],在前面已经排好元素中的位置
for( j = i; j>0 && temp < array[j-1]; j--){
//如果待排元素比array[j-1]小,则array[j-1]后
//移一位,直到待排元素比array[j-1]大,找到插入
//位置
array[j] = array[j-1]; //??
}
array[j] = temp;
System.out.println("第"+ i +"轮排序后:");
display(array);
}
}
- 疑问 ?号那行是否会覆盖数据:并不会覆盖已经排好的元素,因为左边已排好序列全是按从小到大的顺序排好一直到i位置,而i位置的元素是存储在temp中,所以正好后移的元素覆盖该位置,
性能分析:在第一轮排序中,它最多比较一次,第二轮最多比较两次,一次类推,第N轮,最多比较N-1次。因此有 1+2+3+…+N-1 = N*(N-1)/2。
假设在每一轮排序发现插入点时,平均只有全体数据项的一半真的进行了比较,我们除以2得到:N*(N-1)/4。用大O表示法大致需要需要 O(N2) 时间级别。
复制的次数大致等于比较的次数,但是一次复制与一次交换的时间耗时不同,所以相对于随机数据,插入排序比冒泡快一倍,比选择排序略快。
这里需要注意的是,如果要进行逆序排列,那么每次比较和移动都会进行,这时候并不会比冒泡排序快。
对以上三种时间复杂度的总结:
比较次数 交换次数 移动次数
冒泡 n^2/2 最多n^2/2,平均n^2/4 0
选择 n^2/2 最多n-1 0
插入 最多n^2/2,平均n^2/4 0 与比较次数相同
冒泡 必比较
选择 必比较,交换少
插入 一般速度最快 冒泡两倍 比选择略快 逆序速度不比冒泡快 因为比较n^2/2次 还需要移动该次数
快速排序
- 思想:采用分治递归的思想,使得左边比标志位小,右边比标志位大,再对两边选择标志位递归
- 代码实现:
public static void quickSort(int[] numbers,int low,int high)
{
if(low < high)
{
int middle = getMiddle(numbers,low,high); //将numbers数组进行一分为二
quickSort(numbers, low, middle-1); //对低字段表进行递归排序
quickSort(numbers, middle+1, high); //对高字段表进行递归排序
}
}
private static int getMiddle(int[] array, int low, int high){
// 默认标志位从最低位开始
int temp = array[low];
while( low < high){
// 从右端开始找出比标志位小的数
while( low < high && array[high] >= temp){
high--;
}
//将该比标志位小的数放在最左端
array[low] = array[high];
//从最左端开始找到比标志位大的数
while( low < high && array[low] <= temp){
low++;
}
//将该比标志位大的数放在右端
array[high] = array[low];
}
//当low和high相等的时候,跳出循环
array[low] = temp;
//此时标志位的左边均比标志位小,右边比标志位大
return low;
}
- 性能分析:快速排序最优的情况就是每一次取到的元素都刚好平分整个数组,快速排序最优的情况下时间复杂度为:O( nlogn ),快速排序的平均时间复杂度也是:O(nlogn), 最差的情况就是每一次取到的元素就是数组中最小/最大的,这种情况其实就是冒泡排序这种情况时间复杂度就好计算了,就是冒泡排序的时间复杂度:T[n] = n * (n-1) = n^2 + n;综上所述:快速排序最差的情况下时间复杂度为:O( n^2 );如何得出请看快排时间复杂度分析
未完。。
希尔排序
- 希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。
- 实现:
//实现由小到大
public static void sort1(int []arr){
//增量gap,并逐步缩小增量
for(int gap=arr.length/2;gap>0;gap/=2){
//从第gap个元素,逐个对其所在组进行直接插入排序操作
for(int i=gap;i<arr.length;i++){
int j = i;
int temp = arr[j];
if(arr[j]<arr[j-gap]){
while(j-gap>=0 && temp<arr[j-gap]){
//移动法
arr[j] = arr[j-gap];
j-=gap;
}
arr[j] = temp;
}
}
}
}
见图解排序算法
https://www.cnblogs.com/chengxiao/p/6104371.html
堆排序
- 相关知识:
- 堆:堆是具有以下性质的完全二叉树:每个结点的值都大于或等于其左右孩子结点的值,称为大顶堆;或者每个结点的值都小于或等于其左右孩子结点的值,称为小顶堆。即:大顶堆:
arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]
;小顶堆:arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]
- 堆:堆是具有以下性质的完全二叉树:每个结点的值都大于或等于其左右孩子结点的值,称为大顶堆;或者每个结点的值都小于或等于其左右孩子结点的值,称为小顶堆。即:大顶堆:
- 基本思想:将待排序序列构造成一个大顶堆,此时,整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换,此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆,这样会得到n个元素的次小值。如此反复执行,便能得到一个有序序列了
- 具体实现见链接:https://www.cnblogs.com/chengxiao/p/6129630.html