详解五大排序算法

为什么要学习排序

一旦建立一个重要的数据库后，就可能根据某些需求对数据进行不同方式的排序：

比如闹钟功能，按时间远近排序出 闹钟列表，联系人列表按字母A-Z排序，城市列表按省市县的类别排序等等。

排序非常重要而且非常耗时，幸好 人们已经总结出一系列的排序供我们学习，使用。

如何排序？

NBA总决赛正在如火如荼的进行，老詹也正朝着他的第5个总亚军前进着。假设骑士队队员在运动场上排列成一队，如图所示，所有队员已经站好，准备热身，现在需要按身高从低到高 为队员们排队（最矮的站在左边），给他们照一张集体照，应该怎么排队呢？

在排序这件事情上，人与计算机程序相比有以下优势：我可以同时看到所有的队员，并且可以立刻找出最高的一个，毫不费力得测量和比较每一个人的身高。而且队员们不一定要固守特定的空间，他们可以相互推推攘攘就腾出了位置，还能互相前后站立，经过一些具体的调整，毫不费力地给队员们排好队

计算机程序员却不能像人这样通览所有的数据，它只能根据计算机的“比较”操作，在同一时间内对两个队员进行比较，算法 将”比较”的行为视为一个反复出现的问题，在人类看来是非常简单的事情，但程序算法 却只能一步一步得解决具体问题 和遵循一些简单的规则。

算法的本质就是拆分问题，按照最简单的规则，把问题拆分为一步一步交给计算机执行。

看上去这么简单，对吗：

重复这两步循环执行，直到全部有序为止。

不要轻视算法，因每种算法具体实现的细节有所不同。

BUBBLE 冒泡排序

冒泡排序算法运行起来非常慢，但概念上它是排序算法中最简单的，适合刚开始研究算法技术时的入门。


首先由一组无序的数字：

我录制了一段冒泡排序的执行过程（需要1-2秒的缓冲）：

耐心观看完后，我们可以总结出冒泡排序的规则：

1. 比较两个数字
2. 如果左边的数字大，则交换两个数字的位置
3. 向右移动一个位置，比较下两个数字
   
   沿着这个顺序比较下去，一直比较到最右端，虽然没有把所有的数字排好序，但是，数字中最大的那一个已经排放在最右边了，这个是一轮比较下来 可以确定的结果。
   
   下一轮，我们继续从最左边开始。
   
   这也是这个算法被称为冒泡排序的原因：因为在算法执行的时候，最大的数据项 总是 “冒泡”到数组的顶端【数组的排列规则，从左到右0-N】。

效果这么棒，如何开始我们的第一行代码呢？

首先封装一个BUBLE数组对象

class ArrayBub
{
    private long[] a;
    private int nElems;

    public ArrayBub(int max){   
        a =new long[max];   
        nElems=0;   
    }

    public void insert(long value){   
    a[nElems] = value;  
    nElems++;  
    } 

    public void display(){
        for(int j=0 ; j1;out--){  
            for(in=0;ina[in+1] ){
                    swap(in,in+1);
                    }
                }
        }
    }


    private void swap(int one,int  two){
        long temp =a[one]
        a[one] = a[two];
        a[two] = temp;
    }

}

接着测试我们的代码：

class BubbleSortAPP{

    public static void main(String args){

    int maxSize=100;              //数组的长度
    ArrayBub arr;                 //声明我们封装的Bub数组对象
    arr=new ArrayBub(maxSize);    //初始化数组

    arr.insert(77);               //插入10个数据
    arr.insert(22);
    arr.insert(44);
    arr.insert(66);
    arr.insert(88);
    arr.insert(11);
    arr.insert(33);
    arr.insert(77);
    arr.insert(77);
    arr.insert(77);

    arr.display();                 //展示数据

    arr.bubbleSort();              //对数组中的数据 执行排序操作

    arr.display();                 //展示排序后的数据
    }  //end main()
}//end class BubbleSortAPP

核心代码 bubbleSort（）方法只有四行（大括号可以缩进）：

for(out=nElems-1;out>1;out--){  
            for(in=0;ina[in+1] ){  
                    swap(in,in+1);   
                    }
                }
        }

这个算法的思路是要将最小的数据项放在数组的最开始（数组下标为0），并将最大的数据项放在ishuzu的最后（数组下标为nElems-1），外层循环的计数器out，从数组最后开始，即out=nElems-1，每经过一次循环out减1，下标大于out的数据项都已经排好序了，变量out在没完成一次内部循环（计数器为in）后就左移一位，因此算法就不再处理那些已经排好序的数据了。

内循环计数器in从数组的最开始算起，in=0，没弯沉过一次内部循环循环体加1，当它等于out时 结束一次循环，在内存for循环中，数组下标为 in 和in+1的两个数据项比较，如果下标为 in 的数据项大于下标为in+1的数据项，则交换两个数据项。

不变性

在许多算法中，有些条件在算法执行时，是不变的，这些条件称为不变性。认识不变性对理解算法是游泳的，在一定的情况下对调试也有用，可以反复得检查不变性是否为真，如果不是得话 就标记出错。

在上述的bubbleSort.java中，不变性是指 out 右边的所有数据项为有序，在算法的整个运行过程中，这个条件始终为真。（在第一轮排序开始前，尚未排序，而out开始时在数据项的最右边，它已经是最右了，没有数据项在out的右边）

冒泡排序的效率

通过 考察10个数据项，第一轮比较了9次第二轮比较了8次，以此类推 9+8+7+6+5+4+3+2+1=45

小学隔壁家的孩子，高斯同学就已经归纳出这种序列的求和公式：N*(N-1)/2 ;

再运用大学高等数学的 “等价无穷小”定理，在N无限大的情况下， 2和 -1可以忽略不计，从而推导出算法作了N²次比较，而交换次数是小于比较次数的，而且如果数据是随机的，那么大概有一半数据需要交换，交换的次数也是N²，所以我们认为冒泡排序的运行需要O(N²)时间级别，从我录制的gfit原理图来看，冒泡排序的速度是很慢的，

无论何时，只要看到循环嵌套在另一个循环里，就可以怀疑这个算法的运行时间为O(N²)级，

SELECT 选择排序

选择排序改进了冒泡排序，将必要的交换次数从O(N²)减少到O(N)。看上去非常棒了，不幸的时候比较次数仍保持为 O(N²)，不要遗憾，选择排序仍然为大量的排序做出了一个非常重要的改进：

因为izhexie大量的记录 需要在内存中移动，这就使得交换的时间和比较的时间相比，交换的时间更为重要（一般来说，在Java语言中不是这种情况，Java中只是改变了引用位置，而内存中世纪对象的位置并没有发生改变）

理解一下选择排序的原理

一组数据，

选择排序的原理，

* 使用选择排序算法对老詹的队友们排序，*

在选择排序中，不再比较两个相邻的队员，因此，需要记录下某个指定队员的高；可以用记事本记下队员的身高，同时还需要准备好一条紫红色的毛巾（不是搞基）。

进行选择排序 就是把所有的队员扫描一遍，从中选择出最矮的一个队员，最矮的这个队员和站在队列最左端的队员交换位置，即占到0号位置，现在最左端的队员是有序的了，不再需要交换位置。注意，在这个算法中有序的队员都排在队列的最左边（数组中较小的下标值），而冒泡排序则是优先排列在队列的右边。

排序从最左边开始，记录本上写下最左端球员的身高，并且在他的脖子上挂上红色毛巾，于是开始用下一个球员的身高和记录本上记录的值比较，如果下一个球员更矮，则在本子上划掉第一个球员的身高，记录第二个队员的身高，同时把红色毛巾从第一个球员的脖子上拿下来，挂在第二个队员的脖子上，继续沿着队列走下去，

一轮下来，毛巾就会落在最矮的队员面前，接着，唯一拥有红毛巾的队员和队列最左边的队员交换位置，现在已经对一个队员排好序了，这期间做了N-1次比较，淡只进行了一次交换。

嗯，老詹对你的建议很满意。

选择排序的代码实现

class ArraySelect{
    private long[] a;
    private int nElems;

    public ArraySelect(int max){
    a = new long[max];
    nElems = 0;
    }

    public void insert(long value){
    a[nElems] = value;
    nElems++;
    }

    public void display(){
    for(int j=0; j

class SelectSortApp{
    public static void main(String[] args){
    int maxSize = 100;
    ArraySel arr;
    arr = new ArraySel(maxSize)

    arr.insert(88);
    arr.insert(81);
    arr.insert(33);
    arr.insert(87);
    arr.insert(38);
    arr.insert(22);
    arr.insert(11);
    arr.insert(44);
    arr.insert(77);
    arr.insert(99);

    arr.display();

    arr.selectionSort();

    arr.display();

  }//end main()

}//end class

public void insertionSort(）{
    int in,out;
    for(out=left+1;out0&&a[in-1]>=temp){  
            a[in] = a[in-1];  
            --in;   
        }
        a[in] =temp;   
    }
}

class  MergeApp{

    public static void main(String[] args){
        int[] arrayA = {23,47,81,95};
        int[] arrayB = {7,14,39,55,62,74};
        int[] arrayC = new int[10];
        merge(arrayA,4,arrayB,6,arrayC);
    display(arrayC,10);
    }

                                    
    public static void merge(int[] arrayA,int sizeA,
                            int[] arrayB,int sizeB, 
                            int[] arrayC){
        int aDex=0,bDex=0,cDex=0;

        while(aDex 

private void recMergeSort(long[] workSpace,int lowerBound,
                                        int upperBound){
    if(lowerBound ==upperBound)  
         return;
    else{
        int mid=(lowerBound+upperBound)

        recMergeSort(workSpace,lowerBound,mid); 

        recMergeSort(workSpace,mid+1,upperBoud);   

        merge(workSpace,lowerBound,mid+1,upperBound);
    }
}end recMergeSort

class DArray{
    private long[] theArray;
    private int nElems;
    
    public DArray(int max){   
        theArray=new long[max];
        nElems=0;
    }
    
    public void insert(long value){   
        theArray[nElems] =value;
        nElems++;   
    }
    
    public void display(){
        for(int j=0;j

class MergeSortApp
{
    public static void main(String[] args)
    {
        int maxSize=100;   //定义数组的长度
        DArray arr;        
        arr=new DArray(maxSize);  //创建数组

        arr.insert(94);
        arr.insert(64);
        arr.insert(33);
        arr.insert(65);
        arr.insert(65);
        arr.insert(55);
        arr.insert(77);
        arr.insert(11);
        arr.insert(38);
        arr.insert(99);
        arr.insert(25);
        arr.insert(15);

        arr.display();

        arr.mergeSort();

        arr.display();

    }//end main();

}//end class MergeSortApp

划分过程的partition.java

class ArrayPar{
    private long[] theArray;
    private int nElems;
    
    public ArrayPar(int max){
        theArray=new long[max];
        nElems=0;
    }
    
    public void insert(long value){
        theArray[nElems] =value;
        nElems++;
    }
    
    public int size(){
        return nElems;
    }
    
    public void display(){
        System.out.print("A=");
        for(int j=0;jleft &&theArray[--rightPtr]>pivot)
                ;
            if(leftPtr>=rightPtr)  
                break;
            else                   
                swap(leftPtr,rightPtr);     
        }
        return leftPtr;
    }

    
    public void swap(int dex1,int dex2)
    {
        long temp;
        temp=theArray[dex1];
        theArray[dex1]=theArray[dex2];
        theArray[dex2]=temp;
    }
}

class PartitionApp
{
    public static void main(String[] args)
    {
        int maxSize =16;
        ArrayPar arr;
        arr=new ArrayPar(maxSize);
        for(int j=0;j

while(theArray[++leftPtr]
        ;
while(theArray[++rightPtr]>pivot)
        ;
swap(leftPtr,rightPtr);

while(theArray[++leftPtr]pivot)
        ;

public void recQuickSort(int left,int right)
{
    if(right-left<=0)  
        return;
    esle
    {
        int partition=partitionIt(left,right);
        recQuickSort(left,partition-1); 
        recQuickSort(partition+1,right);  
    }
}

class ArrayIns
{
    private long[] theArray;
    private int nElems;
    
    public ArrayIns(int max)
    {
    theArray=new ArrayIns(max);
    nElems=0;
    }
    
    public void insert(long value)
    {
    theArray[nElesm]=value;
    nElems++;
    }
    
    public void display()
    {
        System.out.print("A=");
        for(int j=0;jtheArray[center])
            swap(left,center);
        if(theArray[left]>theArray[right])
            swap(left,right);
        if(theArray[center]>theArray[right])
            swap(center,right);

        swap(center,right-1);   
        return theArray(right-1);   
    }
    
    public void swap(int dex1,int dex2)
    {
        long temp;
        temp=theArray[dex1];
        theArray[dex1]=theArray[dex2];
        theArray[dex2]=temp;
    }
    
    public int partitionIt(int left,int right,long pivot)
    {
        int leftPtr=left;
        int rightPtr=right-1; 

        while(true)
        {
            while(theArray[++leftPtr]pivot)
                ;

            if(leftPtr>=rightPtr)
                break;
            else
                swap(leftPtr,rightPtr);
        }
        swap(leftPtr,right-1);  
        return leftPtr;
    }
    
    public void manualSort(inr left,int right)
    {
        int size=right-left+1;
        if(size<=1)  
            return;
        if(size==2)
            {
                if(theArray[left]>theArray[right])
                    swap(left,right);   
                return
            }else   
            {
                if(theArray[left]>theArray[right-1])
                    swap(left,right-1);
                if(theArray[left]>theArray[right])
                    swap(left,right);
                if(theArray[right-1]>theArray[right])
                    swap(right-1,right);
            }
    }
}

class QuickSortApp
{
    public static void main(String args)
    {
        int maxSize=16;
        ArrayIns arr;
        arr=new ArrayIns(maxSize);
        for(int j=0;j

class ArrayIns
{
    private long[] theArray;
    private int nElems;
    
    public ArrayIns(int max)
    {
    theArray=new ArrayIns(max);
    nElems=0;
    }
    
    public void insert(long value)
    {
    theArray[nElesm]=value;
    nElems++;
    }
    
    public void display()
    {
        System.out.print("A=");
        for(int j=0;jtheArray[center])
            swap(left,center);
        if(theArray[left]>theArray[right])
            swap(left,right);
        if(theArray[center]>theArray[right])
            swap(center,right);

        swap(center,right-1);   
        return theArray(right-1);   
    }
    
    public void swap(int dex1,int dex2)
    {
        long temp;
        temp=theArray[dex1];
        theArray[dex1]=theArray[dex2];
        theArray[dex2]=temp;
    }
    
    public int partitionIt(int left,int right,long pivot)
    {
        int leftPtr=left;
        int rightPtr=right-1; 

        while(true)
        {
            while(theArray[++leftPtr]pivot)
                ;

            if(leftPtr>=rightPtr)
                break;
            else
                swap(leftPtr,rightPtr);
        }
        swap(leftPtr,right-1);  
        return leftPtr;
    }
    
    public void insertionSort(）{
        int in,out;
        for(out=left+1;out0&&theArray[in-1]>=temp)
            {  
            theArray[in] = a[in-1];  
            --in;   
            }
            theArray[in] =temp;   
        }
    }

}

class Quick2SortApp
{
    public static void main(String args)
    {
        int maxSize=16;
        ArrayIns arr;
        arr=new ArrayIns(maxSize);
        for(int j=0;j