所有内部排序算法的一个总结表格
简单选择排序
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
最差:O(n2)
最优:O(n2)
平均:O(n2)
public void selectSort(int[] a){
for(int i=0;i冒泡排序
冒泡排序算法的运作如下：
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
最差:O(n2)
最优:O(n)
平均:O(n2)
public static void bubbleSort(int[] a){
for(int i=0;ia[j+1]) {int temp=a[j];a[j]=a[j+1];a[j+1]=temp;}//交换元素位置 保证大的在后面
}
}
}
插入排序
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
- 从第一个元素开始，该元素可以认为已经被排序
- 取出下一个元素，在已经排序的元素序列中从后向前扫描
- 如果该元素（已排序）大于新元素，将该元素移到下一位置
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
- 将新元素插入到该位置后
- 重复步骤2~5
最差:O(n2)
最优:O(n)
平均:O(n2)
直接插入排序:
public static void insertSort(int[] a){
for(int i=1;i=a[i]){//找到了第一个比自己大的元素,插入到该元素之前
int temp=a[i];
for(int k=i-1;k>=j;k--) a[k+1]=a[k];//每个元素向后移动一格
a[j]=temp;
break;
}
}
}
}
折半插入排序: 就是寻找第一个比自己大的元素的时候用折半查找进行优化:
public static void halfInsertSort(int[] a){
for(int i=1;i=low;k--) a[k+1]=a[k];//每个元素向后移动一格
a[low]=temp;
}
}
快速排序
快速排序使用分治法策略来把一个序列（list）分为两个子序列（sub-lists）。
步骤为：
- 从数列中挑出一个元素，称为"基准"（pivot)
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
最差:O(n2)
最优:O(n log n)
平均:O(n log n)
//这里left取0,right取a.length-1
public static void quickSort(int[] a,int left,int right){
if(left=x) j--;//从右向左找第一个小于x的数
if(i 当前选取第一个元素作为标尺是比较不好的,一种安全的做法是随记选取,但是也不好.我们一般采用三数中值分割法,就是使用左端,右端,中心位置上的三个元素的中位数作为标尺进行排序.
public static void quickSortS(int[] a,int left,int right){
if(left=x) j--;//从右向左找第一个小于x的数
if(i 希尔排序
希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。
根据步长进行分组,对每一组进行插入排序.
最差:O(因步长各异,最好的n log2 n)
最优:O(n)
平均:O(因步长各异)
public static void shellSort(int[] a){
int igap=a.length;//初始化步长,第一次步长为数组长度的一半
for(int gap=igap/2;gap>0;gap/=2){//步长
for(int i=0;i=a[j]){//找到了第一个比自己大的元素,插入到该元素之前
int temp=a[j];
for(int p=j-1;p>=k;p--) a[p+1]=a[p];//每个元素向后移动一格
a[k]=temp;
break;
}
}
}
}
}
}
归并排序
原理如下（假设序列共有n个元素）：
- 将序列每相邻两个数字进行归并操作，形成floor(n/2)个序列，排序后每个序列包含两个元素
- 将上述序列再次归并，形成floor(n/4)个序列，每个序列包含四个元素
- 重复步骤2，直到所有元素排序完毕
最差:O(n logn)
最优:O(n)
平均:O(n log n)
public static void mergeSort(int[] a,int first,int last){
if(first树形选择排序
树形选择排序（Tree Selection Sort），又称锦标赛排序（Tournament Sort），是一种按照锦标赛思想进行选择排序的方法。
首先对n个记录的关键字进行两两比较，然后在其中[n/2]（向上取整）个较小者之间再进行两两比较，如此重复，直至选出最小关键字的记录为止。
这个过程可以用一颗有n个叶子节点的完全二叉树表示,每个非终端节点都是左右孩子中的较小值,这样根节点就是所有叶子节点中的最小值了.把这个值输出后,将叶子节点中的最小值改为"最大值",然后从该叶子节点开始,和其左右兄弟进行比较,修改从叶子节点到根节点的路径上各节点的值,则根节点的值为次小值.同理,可从小到大排出所有值.
虽然说树,但是通常由数组实现,父节点i的左子节点在位置(2i+1);父节点i的右子节点在位置(2i+2);子节点i的父节点在位置floor((i-1)/2)
时间复杂度为O(n log n)
缺点是辅助存储空间太多,并且与"最大值"进行了多余的比较.
public static int[] TreeSelectSort(int[] data){
int dlong=data.length;
int tlong=2*dlong-1;
int low=0;
int[] tree=new int[tlong];
int[] ndata=new int[dlong];
for(int i=0;i0;i-=2){
tree[(i-1)/2]=(tree[i]0){//有父节点
if(minIndex%2==0){//是右节点
tree[(minIndex-1)/2]=(tree[minIndex] 堆排序
堆排序是对树形选择排序的一种优化,建立在"二叉堆"这种数据结构上,二叉堆属于完全二叉树,除此之外还需满足所有父节点都要大于或小于左右子树.
父节点大于左右孩子的叫最大二叉堆,父节点小于左右孩子的叫最小二叉堆.
以最大二叉堆为基础进行排序,就是先构建成一个最大堆,接着取出根节点,然后将剩下的数组元素在建成一个最大二叉堆,再取出根节点,如此循环直到所有元素都被取光.
和树形选择排序一样也是由数组实现,参考上一节.
最坏,最优和平均的时间复杂度都是nlogn.
public static void heapSort(int[] a){
//建立最大堆
int size=a.length;
for(int i=(size-1-1)/2;i>=0;i--){
maxHeap(i,a,size);
}
for(int i=a.length-1;i>0;i--){
//将根节点上的最大值不断与最后一个交换,并将最后一个筛选出来,指向最后的指针向前推进
int temp=a[i];
a[i]=a[0];
a[0]=temp;
size--;
//保证根节点最大特性,其他节点都已经保持了
maxHeap(0, a,size);
}
}
//保持堆的最大特性
private static void maxHeap(int i,int[] a,int size) {
int left=2*i+1;
int right=2*i+2;
int largest=i;
//分别与左右子树比较,取最大值
if(left<=size-1&&a[left]>a[i]){
largest=left;
}
if(right<=size-1&&a[right]>a[largest]){
largest=right;
}
if(largest!=i){
//交换根节点与最大值
int temp=a[i];
a[i]=a[largest];
a[largest]=temp;
//递归
maxHeap(largest, a,size);
}
}
桶排序
桶排序(Bucket Sort)的原理很简单，它是将数组分到有限数量的桶子里。
假设待排序的数组a中共有N个整数，并且已知数组a中数据的范围[0, MAX)。在桶排序时，创建容量为MAX的桶数组r，并将桶数组元素都初始化为0；将容量为MAX的桶数组中的每一个单元都看作一个"桶"。
在排序时，逐个遍历数组a，将数组a的值，作为"桶数组r"的下标。当a中数据被读取时，就将桶的值加1。例如，读取到数组a[3]=5，则将r[5]的值+1。
桶排序的时间复杂度为O(n+k),k为取值范围,在特殊情况下提供了排序的下界.
public static void bucketSort(int[] a,int max){
int[] buckets;
if(a==null||max<1){
return;
}
buckets=new int[max];//创建一个容量为max的数组 并将其数据都初始化为0
//计数
for(int i=0;i0){
a[j++]=i;
}
}
buckets=null;
}
基数排序(多关键字排序)
基数排序已经不再是一种常规的排序方式，它更多地像一种排序方法的应用，基数排序必须依赖于另外的排序方法。基数排序的总体思路就是将待排序数据拆分成多个关键字进行排序，也就是说，基数排序的实质是多关键字排序。
多关键字排序时有两种解决方案：
最高位优先法（MSD）(Most Significant Digit first)
最低位优先法（LSD）(Least Significant Digit first)
这里我们采用LSD,对关键字的排序采用桶排序,那么实质上就变成了多次桶排序.
时间复杂度为O(d(n+k),d为关键字个数,k为取值范围
数字是四位数之内,所以四个关键字为个十百千位的值.
//假定四位数字内比较,有四个关键字,个十百千位,同一关键字使用桶排序
public static void radixSort(int[] a,int max,int d){
int rate=1;//表示关键字层级
int[] buckets=new int[max];//存放个位数,十位数,百位数....
List[] temp=new List[max];//存放缓存数字
for(int i=0;i();//用list数组来存放缓存数字
temp[subKey].add(a[j]);
buckets[subKey]++;//计数+1
}
//进行排序,就是按顺序取
for(int j=0,k=0;j0){
a[k++]=temp[j].get(t);
t++;
}
}
rate*=max;
}
}
由于数组操作起来是比较麻烦,非要通过数组存储的话只能存储次数不能存储整个数字,那取出来的时候我还没想到好的方法把它还原成数字了.所以我就采取了很笨的方法,再用一个缓存list数组存数字...
当然这很浪费空间,也很麻烦,直接用链表简单很多
public static void linkedRadixSort(int[] a,int max,int d){
ArrayList list=new ArrayList();
int rate=1;
for(int i=0;i());
}
for(int j=0;j0 && list.get(j)!=null){
a[k]=(Integer) list.get(j).remove(0);
k++;
}
}
rate*=max;
}
}
虽然说是用链表的,但是收集起来的时候仍然是放数组的,仍要开辟许多空间.于是我们采用链式基数排序
所谓链式,就是用链表存储,前一个分组的尾指针指向下一个分组的头指针这样,这样链表很容易做到.
public static void linkedRadixSortS(Integer[] a,int max,int d){
List slist=new ArrayList();
ArrayList list=new ArrayList();
int rate=1;
slist.addAll(Arrays.asList(a));
for(int i=0;i());
}
while(slist.size()>0){
int num=slist.remove(0);
int subKey=(num/rate)%max;
list.get(subKey).add(num);
}
for(int j=0;j 上面三种只是空间上的优化,对于时间复杂度是没有影响的.
外部排序
之前所有的排序算法都属于内部排序,需要将输入数据装入内存中.然而在一些应用程序中,它们的输入数据量太大装不进内存,这时候就需要外部排序了.
基本外部排序算法使用归并排序.设有四盘磁带,Ta1,Ta2,Tb1,Tb2,磁带a和磁带b或者用作输入磁带,或者用于输出磁带.从输入磁带一次读入M(我们取3)个记录,在内部将这些记录排序,然后再交替地写到Tb1或Tb2上,将每组排过序的记录叫做一个顺串.
现在Tb1和Tb2都包含了一些顺串.我们将每个磁带的第一个顺串取出将两者合并,把结果写到Ta1上,该结果是一个二倍长的顺串.然后我们再从每盘磁带取出下一个顺串,合并然后写到Ta2上.继续这个过程直达Tb1或Tb2为空.继续这个过程直到得到长为N的一个顺串,这个算法需要log(N/M)趟工作,见下图
如果我们有额外的磁带,那么我们可以减少将输入数据排序的趟数,将基本的(2-路)合并扩充为(k-路)合并就可以做到这一点.这就是所谓的多路合并
上面讨论的k-路合并方案需要使用2k盘磁带,其实我们通过只使用k+1盘磁带也可以完成排序的工作,就是所谓的多相合并.以三盘磁带完成2-路合并为例:
这儿顺串最初的分配是一个关键的问题,其实采用斐波那契数是最优的.
对于顺串的构造还可以采用置换选择排序,采用堆的思想构建,具有特别的价值.
接下来实现完整的外部排序
package com.fredal.structure;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Random;
public class ExternalSort {
public static int BUFFER_SIZE = 10;
public File sort(File file) throws IOException {
ArrayList files = split(file);
return process(files);
}
// recursive method to merge the lists until we are left with a
// single merged list
private File process(ArrayList list) throws IOException {
if (list.size() == 1) {
return list.get(0);
}
ArrayList inter = new ArrayList();
for (Iterator itr = list.iterator(); itr.hasNext();) {
File one = itr.next();
if (itr.hasNext()) {
File two = itr.next();
inter.add(merge(one, two));
} else {
return one;
}
}
return process(inter);
}
/**
* Splits the original file into a number of sub files.
*/
private ArrayList split(File file) throws IOException {
ArrayList files = new ArrayList();
int[] buffer = new int[BUFFER_SIZE];
FileInputStream fr = new FileInputStream(file);
boolean fileComplete = false;
while (!fileComplete) {
int index = buffer.length;
for (int i = 0; i < buffer.length && !fileComplete; i++) {
buffer[i] = readInt(fr);
if (buffer[i] == -1) {
fileComplete = true;
index = i;
}
}
if (buffer[0] > -1) {
Arrays.sort(buffer, 0, index);
File f = new File("set" + new Random().nextInt());
FileOutputStream writer = new FileOutputStream(f);
for (int j = 0; j < index; j++) {
writeInt(buffer[j], writer);
}
writer.close();
files.add(f);
}
}
fr.close();
return files;
}
/**
* Merges two sorted files into a single file.
*
* @param one
* @param two
* @return
* @throws IOException
*/
private File merge(File one, File two) throws IOException {
FileInputStream fis1 = new FileInputStream(one);
FileInputStream fis2 = new FileInputStream(two);
File output = new File("merged" + new Random().nextInt());
FileOutputStream os = new FileOutputStream(output);
int a = readInt(fis1);
int b = readInt(fis2);
boolean finished = false;
while (!finished) {
if (a != -1 && b != -1) {
if (a < b) {
writeInt(a, os);
a = readInt(fis1);
} else {
writeInt(b, os);
b = readInt(fis2);
}
} else {
finished = true;
}
if (a == -1 && b != -1) {
writeInt(b, os);
b = readInt(fis2);
} else if (b == -1 && a != -1) {
writeInt(a, os);
a = readInt(fis1);
}
}
os.close();
return output;
}
private void writeInt(int value, FileOutputStream merged)
throws IOException {
merged.write(value);
merged.write(value >> 8);
merged.write(value >> 16);
merged.write(value >> 24);
merged.flush();
}
private int readInt(FileInputStream fis) throws IOException {
int buffer = fis.read();
if (buffer == -1) {
return -1;
}
buffer |= (fis.read() << 8);
buffer |= (fis.read() << 16);
buffer |= (fis.read() << 24);
return buffer;
}
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
File file = new File("mainset");
Random random = new Random(System.currentTimeMillis());
FileOutputStream fw = new FileOutputStream(file);
for (int i = 0; i < BUFFER_SIZE * 3; i++) {
int ger = random.nextInt();
ger = ger < 0 ? -ger : ger;
fw.write(ger);
fw.write(ger >> 8);
fw.write(ger >> 16);
fw.write(ger >> 24);
}
fw.close();
ExternalSort sort = new ExternalSort();
System.out.println("Original:");
dumpFile(sort, file);
File f = sort.sort(file);
System.out.println("Sorted:");
dumpFile(sort, f);
}
private static void dumpFile(ExternalSort sort, File f)
throws FileNotFoundException, IOException {
FileInputStream fis = new FileInputStream(f);
int i = sort.readInt(fis);
while (i != -1) {
System.out.println(Integer.toString(i));
i = sort.readInt(fis);
}
}
}
更多文章与相关下载请看扩展阅读