以前经常困惑于排序算法的设计,不能深入理解和应用,因此决定采用临摹复述的方式达到加深理解和记忆的效果.
排序算法依据排序过程中使用内存或外存而分为内排序和外排序.
一.内排序可以分为以下几类:
1. 插入排序:直接插入排序,二分法插入排序,希尔排序.
2. 选择排序:简单选择排序,堆排序
3. 交换排序:冒泡排序,快速排序
二.外排序(既使用内部存储,也使用外部存储,内存不够时建议使用)可以分为以下几类:
1. 归并排序
2. 基数排序
稳定性
就是能保证排序前两个相等的数据在其序列中的先后位置与排序后先后顺序相同.
稳定性算法:冒泡排序,直接插入排序,二分法插入排序,归并排序和基数排序都是稳定的排序算法
不稳定算法:简单选择排序,快速排序,希尔排序,堆排序不是稳定的排序算法
平均时间复杂度
O(n^2):直接插入排序,简单选择排序,冒泡排序,性能为O(n^2)的算法基本上都是相邻元素进行比较,基本上都是稳定的.
O(n*logn):快速排序,归并排序,希尔排序,堆排序,一般情况下快排比归并和希尔排序好,堆排序在数据量很大时较优异.
排序算法的选择
1.数据规模较小:
(1)对稳定性不做要求时宜用简单选择排序,对稳定性有要求宜用插入或冒泡
2.数据量规模不是很大:
(1)对稳定性没有要求,快排,要付出log(N)的额外空间
(2)对稳定性有要求,空间允许下,宜用归并排序
3.数据量很大
(1)对稳定性有要求,可以考虑归并排序
(2)对稳定性没有要求,宜用堆排序
4.序列初始基本有序(正序):宜用直接插入,冒泡
一.插入排序
•思想:每次将一个待排序的记录插入到前面已经排好序的序列中合适位置
•关键问题:在已经排序的序列中找到合适的插入位置
•方法:
1.直接插入排序(从后向前找到合适的位置)
public int[] insertSort(int[] array) {
int tmp;
for(int i=1;i<array.length;i++) {
for(int j=i,j>0;j--) {
if(array[j] < array[j-1]) {
tmp = array[j];
array[j] = array[j-1];
array[j-1] = tmp;
}
}
}
return array;
} 算法分析:文件初始状态不同,直接插入排序所耗费的时间有很大差异,若文件一开始为正序,则待插入记录只需要比较一次就能找到合适的插入位置,
这是最好的情况,算法时间复杂度为O(n),若文件一开始为逆序,则第i个待插入数据需要比较i次才能找到合适的插入位置,故时间复杂度为O(n^2),
这是最坏的情况,直接插入排序的平均时间复杂度为O(n^2).
2.二分插入排序(按二分法找到合适的插入位置)
public int[] divideSort(int[] array) {
for(int i=1;i<array.length;i++) {
int tmp = array[i];
int low = 0;
int high = i-1;
while(low <= high) {
int mid = (low + high)/2;
if(tmp < array[mid]) {
high = mid-1;
}else {
low = mid+1;
}
}
for(int j=i-1;j>=low;j--) {
//将最新生成low位置到排序前最后位置处元素向后移动
array[j+1] = array[j];
}
if(low != i) {
array[low] = tmp;
}
}
return array;
} 二分插入排序的时间复杂度比直接插入排序要低,算法移动次数与直接插入排序相同,最坏情况为n^2/2,最好情况为n,平均移动次数为O(n^2).
3.希尔排序(先取一个小于n的整数d1作为第一个增量,把文件的全部数据分成d1个分组,所有距离为d1的倍数的数据放在同一个组中.
先在各组内进行直接插入排序.然后去第二个增量d2
public int[] shellSort(int[] array) {
int len = array.length;
int interval = len;
while(true) {
interval = interval/2; //哈哈,发现一个bug,如果除数取的不巧可能会跳不出循环
for(int i=0;i<interval;i++) {
for(int j=i+interval;j<len;j+=interval) {
int tmp = array[j];
int k;
for(k=j-interval;k>=0;k-=interval) {
if(array[k] > tmp) {
array[k+interval] = array[k];
}else {
break;
}
}
array[k+interval] = tmp;
}
}
if(interval == 1) {
break;
}
}
return array;
} 算法分析:希尔排序是文件在每一次排序过程中更加接近于有序状态,在效率上比直接插入排序有较大的改进,
希尔排序的平均时间复杂度为O(n*logn).
二.选择排序
•思想:每次从待排序的数据中选择关键字最小的数据放置到已排序表的最前面位置,直到全部排序.
•关键问题:在剩余待排序数据中找到最小数据
方法:
1.直接选择排序(在排序数组中选择最小数据与第一个位置数据交换,再在剩下数中找最小的数据与第二个位置交换,直到倒数第二和倒数第一个数据比较)
public int[] selectSort(int[] array) {
int len = array.length;
for(int i=0;i<len-1;i++) {
int min = array[i];
int n = i;
for(int j=i+1;j<len;j++) {
if(min > array[j]) {
min = array[j];
n = j;
}
}
array[n] = array[i];
array[i] = min;
}
return array;
} 算法分析:简单寻找排序是不稳定的排序,时间复杂度O(n^2).
2.堆排序(堆排序是一种树形选择排序,是对直接选择排序的有效改进)
堆:具有n个元素的序列(h1,h2,…,hn),当且仅当满足(hi>=h2i,hi>=2i+1)或(hi<=h2i,hi<=h2i+1),称为堆,
完全二叉树可以很直观的表示为堆的结构,堆顶为根,其余为左子树,右子树.
思想:1.初始调整堆的存储顺序,得到根节点最大的堆;2.将根节点与堆的最后一一个节点交换,然后对前面(n-1)个数据重新调整为最大堆.
直到只有两个节点的堆,并对他们做交换,得到完全有序的序列.
public int[] heapSort(int[] array) {
int len = array.length;
for(int i=0;i<len-1;i++) {
buildMaxHeap(array,len-1-i);
swap(array,0,len-1-i);
}
return array;
}
public static void buildMaxHeap(int[] array,int index) {
for(int i=(index-1)/2;i>=0;i--) {
int k = i;
while(k*2+1 <= index) {
int biggerIndex = 2*k+1;
//如果biggerIndex小于index,即biggerIndex代表的节点的右子节点存在
if(biggerIndex < index) {
if(array[biggerIndex] < array[biggerIndex+1]) {
biggerIndex++;
}
}
//如果k节点的值小于其较大的子节点的值
if(array[k] < array[biggerIndex]) {
swap(array, k, biggerIndex);
k = biggerIndex;
}else {
break;
}
}
}
}
public static void swap(int[] array,int i,int j) {
int tmp;
tmp = array[j];
array[j] = array[i];
array[i] = tmp;
} 算法分析:堆排序不稳定排序算法, 堆排序可以通过树形结构保存部分比较结果, 可减少比较次数. 堆排序最坏时间复杂度为O(n*logn). 堆排序的平均性能接近于最坏性能. 由于初始建堆所需的比较次数较多, 所以堆排序不适合数据较少的文件.
三.交换排序
1.冒泡排序:
•思想:对未排序的数据从头至尾对相邻的两个数据进行比较和交换,让较大的数据下沉,较小的数据往上冒.
public int[] bubbleSort(int[] array) {
int len = array.length;
for(int i=0;i<len;i++) {
for(int j=0;j<len-i-1;j++) {
if(array[j] > array[j+1]) {
int tmp = array[j];
array[j] = array[j+1];
array[j+1] = tmp;
}
}
}
return array;
} 算法分析:若文件数据为正序, 则一趟冒泡就可以完成排序, 排序比较次数为n-1, 且没有数据移动,时间复杂度为O(n); 若文件数据为逆序,则需要n-1趟冒泡, 每趟进行n-i次排序比较, 切每次比较都移动3次, 比较和移动次数均达到最大值:O(n^2). 冒泡排序平均时间复杂度为O(n^2).
2.快速排序
•思想:选择一个基准元素,通常选择第一个元素或最后一个元素,通过一趟扫描,将待排序序列分成两部分,一部分比基准小,另一部分比基准小,
此时基准元素在其排好序的正确位置,然后再用同样的方法递归的排序划分的两部分.
public int[] quickSort(int[] array) {
int len = array.length;
base(array, 0, len-1);
return array;
}
public void base(int[] array,int low,int high) {
if(low < high) {
int middle = getMiddle(array,low,high);
base(array, 0, middle-1);
base(array, middle+1, high);
}
}
public int getMiddle(int[] array,int low,int high) {
//基准元素
int tmp = array[low];
while(low < high) {
while(low < high && array[high] >= tmp) {
high--;
}
array[low] = array[high];
while(low < high && array[low] <= tmp) {
low++;
}
array[high] = array[low];
}
array[low] = tmp;
return low;
} 算法分析:快速排序因为不是相邻元素间比较,所以不是稳定的排序, 快速排序的时间复杂度为O(n*logn), 当n较大用快排比较好, 当序列基本有序用快排反而不好.
四.归并排序
•思想:归并排序将两个(或两个以上)有序表合成一个新的有序表,即把待排序序列分成若干个子序列,每个子序列有序后,将有序子序列合并成为整体有序序列.
public int[] mergeSort(int[] array) {
int len = array.length;
slice(array,0,len-1);
return array;
}
public void slice(int[] array,int low,int high) {
if(low < high) {
int middle = (low+high)/2;
slice(array, low, middle);
slice(array, middle+1, high);
merge(array,low,middle,high);
}
}
public void merge(int[] array,int low,int middle,int high) {
int[] tmpArr = new int[array.length];
int mid = middle+1;
int tmp = low;
int third = low;
while(low <= middle && mid <= high) {
//从两个数组中选取较小的数放入中间数组
if(array[low] <= array[mid]) {
tmpArr[third++] = array[low++];
}else {
tmpArr[third++] = array[mid++];
}
}
//将剩余的部分放入中间数组
while(low <= middle) {
tmpArr[third++] = array[low++];
}
while(mid <= high) {
tmpArr[third++] = array[mid++];
}
//将中间数组复制回原数组
while(tmp <= high) {
array[tmp] = tmpArr[tmp++];
}
} 算法分析:归并排序为稳定的排序算法, 时间复杂度O(n*logn). 速度仅次于快速排序, 一般用于整体无序, 但子项相对有序数列.
五.基数排序
•思想:将所有带比较数值(正整数)统一为同样长度的数位长度,数位较短的前面补0,然后从最低位开始依次进行一次排序.
public int[] baseSort(int[] array) {
//找到最大数,确定排序次数
int max = 0;
for(int i=0;i<array.length;i++) {
if(max < array[i]) {
max = array[i];
}
}
//判断位数
int times = 0;
while(max > 0) {
max = max/10;
times++;
}
//建立10个队列
List<ArrayList<Integer>> queue = new ArrayList<>();
for(int i=0;i<10;i++) {
ArrayList<Integer> queue1 = new ArrayList<>();
queue.add(queue1);
}
//进行times次分配和收集
for(int i=0;i<times;i++) {
//分配
for(int j=0;j<array.length;j++) {
int x = array[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i);
ArrayList<Integer> queue2 = queue.get(x);
queue2.add(array[j]);
queue.set(x, queue2);
}
//收集
int count = 0;
for(int j=0;j<10;j++) {
while(queue.get(j).size() > 0) {
ArrayList<Integer> queue3 = queue.get(j);
array[count] = queue3.get(0);
queue3.remove(0);
count++;
}
}
}
return array;
}算法分析:基数排序是稳定的排序算法,基数排序的时间复杂度为O(d(n+r)),d为位数,r为基数.
扫一扫
8874
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
