深入理解排序算法java版

简单插入排序

插入排序的基本思想是将整个排序序列划分成“有序区间”和“无序区间”，然后逐个将无序区间中的元素插入到前面有序区间了，逐步将这个区间变有序。其算法复杂度为O(n^2)
其算法描述如下：

描述：插入排序输入：待排序数组array,数组最后一个元素位置lastIndex输出：排序好的数组array从i=2位置作为待插入元素，直至最后一个元素，循环如下操作    设置array[0]为待待插入值array[i]作为哨兵    取出待插入值tmp=array[i]    从j=i位置开始循环        如果tmp小于array[j-1],array[j]=array[j-1]        否则，结束循环        j减一    j为最终的插入位置，array[j]=tmp

其java实现如下

    /**     * 插入排序，数组从1开始存放     * @param array     * @param lastIndex 要排序的最后一个元素的位置     */    public void insertSort(T[] array, int lastIndex) {        for(int i=2;i<=lastIndex;i++) {            array[0]=array[i];//标兵位            int j;            for(j=i;array[0].compareTo(array[j-1])<0;j--) {                array[j]=array[j-1];            }            array[j]=array[0];        }    }

希尔排序

希尔排序是插入排序的一个变种，它使用缩减的增量来进行插入排序，它的时间复杂度达到了O(n^3/2),也就是亚平方级别。
其算法描述如下：

描述：希尔排序算法输入：待排序数组array,数组最后一个元素位置lastIndex输出：排序好的数组array从gap=lastIndex/2开始，在gap>0时，每次gap/2, 循环以下操作    从i=gap+1位置开始，在i<=lastIndex时，i每次加1, 循环以下操作        tmp=array[i],取出当前待排序元素        从j=i开始，在j>=gap时，j每次减gap,循环以下操作            如果tmp<array[j],array[j]=array[j-gap]        array[j]=tmp

其java实现如下

    public void shellSort(T[] array, int lastIndex) {        for(int gap= lastIndex/2;gap>0; gap/=2) {//确定不同的增量过程            for(int i=gap+1;i<=lastIndex;i++){//从第一个增量后的值开始到最后所有的值                T tmp=array[i];                int j;                for(j=i; j>gap&&tmp.compareTo(array[j-gap])<0; j-=gap)                     array[j]=array[j-gap];                array[j]=tmp;            }        }    }

堆排序

如果我们想要从小到大排序，那么我们需要使用大根堆进行堆排序的过程，堆排序有两个主要过程：初始建堆过程和移除堆顶元素进行调整的过程，两个过程都用到了“下滤”的调整算法，整个堆排序的算法复杂度可以是O(N logN)，其实现思路如下。
首先是下滤的过程

描述：大根堆的下滤调整过程输入：大根堆的数组array,数组的最后一个元素位置lastIndex,要调整的节点位置i输出：下滤位置i元素后的数组取出当前要挑战节点的值value=array[i]如果i*2<=lastIndex,进行如下循环    选取i节点值左右孩子节点（i*2和i*2+1）值较大的节点位置为child    如果array[child]>value,令array[i]=array[child]    否则，结束循环    i=childarray[i]=value

初始建堆的过程很简单，就是从最后一个非叶子节点开始进行下滤，直至根节点，其java代码如下

    private void buildHeap(T[] array, int lastIndex) {        for(int i=lastIndex/2;i>0;i--)            percDown(i,array,lastIndex);    }    private void percDown(int i, T[] array, int lastIndex) {        T tmp=array[i];        int child;        while(i*2<=lastIndex) {            child =i*2;            if(child!=lastIndex&&array[child].compareTo(array[child+1])<0)                child++;            if(tmp.compareTo(array[child])<0)                array[i]=array[child];            else                break;            i=child;        }        array[i]=tmp;    }

写完了下滤过程，那么我们的堆排序过程就可以利用下滤调整的过程来进行描述

描述：堆排序输入：待排序数组array,数组最后一个元素位置lastIndex输出：排序好的数组array堆数组array中1-lastIndex的元素进行初始建堆从i=lastIndex开始，在i>1成立时，每次i-1,做如下循环    交换1位置和i位置的值    对从1位置的值在数组array中1到i-1进行下滤操作结束

其java代码如下

    public void heapSort(T[] array, int lastIndex) {        buildHeap(array,lastIndex);//从小到大排序建立大根堆        T tmp;        for(int i=lastIndex;i>1;i--) {            tmp=array[i];            array[i]=array[1]; //将首节点移到1最后            array[1]=tmp;//复制另一个节点            percDown(1, array, i-1);        }    }

快速排序

正如起名，快速排序是使用最为广泛的一种排序算法，它采用了分治的策略，所以很容易用递归的方式来描述整个过程，快速排序的统计效率达到了O(N logN)，但是实际上快速排序的最坏情况可以达到O(N^2),算法的实际效率和选取的轴值有密切的关系。
简单的讲来，我们首先从待排序序列中选取一个轴值，根据这个轴值将整个序列划分成两部分，左边的部分所有的值小于轴值，而右边的部分所有的值大于轴值，然后我们再采用同样的方法对左右两部分进行排序，直到每部分只有一个值为止。详细的算法描述如下

描述：快速排序输入：待排序数组array,待排序的第一个元素位置left,最后一个元素位置right输出：排序好的array如果left<right,进行如下操作    令low=left，high=right    零pivotValue=array[low]    当low<high的时候循环执行如下操作        当low<high并且array[high]>pivot值的时候，循环执行            high--        array[low]=array[high]        当low<high并且array[low]<pivot值的时候，执行循环            low++        array[high]=array[low]    array[low]=pivot的值quickSort(array,left,low-1),对left到low-1位置的元素进行操作quickSort(array,low+1,right)，堆low+1到right位置的元素进行操作

其代码如下

    public void quickSort(T[] array, int left, int right) {//元素从1开始存放        if(left<right) {            int low=left;            int high=right;            T pivot=array[low];            while(low<high) {                while(low<high&&array[high].compareTo(pivot)>0)                     high--;//右指针左移                array[low]=array[high];                while(low<high&&array[low].compareTo(pivot)<0)                    low++;//左边的较小，左移                array[high]=array[low];            }            array[low]=pivot;            quickSort(array, left, low-1);            quickSort(array, low+1, right);        }    }

归并排序

归并排序也是一个O(N logN)的排序算法，但是归并排序需要额外O(N)的空间，归并排序的基本操作是将两个排序好的数组进行合并，而合并的过程不可避免的要使用临时数组。
合并的简述过程是这样的，对于A,B两个排序好的数组，合并到数组C。A，B各维护一个指针pa,pb指向当前扫描到的位置，如果A[pa]

描述：归并排序输入：待排序数组array,待排序最左边的元素位置left，最右边的元素位置right输出：排序好的数组array如果left<right，就可以进行如下操作    center=(left+right)/2    排序left到center位置的元素    排序center+1到right位置的元素    合并array[left到center]和array[center+1到right]

其算法实现如下

    public void mergeSort(T[] array, int lastIndex) {        T[] tmpArray=(T[]) new Comparable[lastIndex+1];        mergeSort(array, tmpArray, 1, lastIndex);    }    void mergeSort(T[] array, T[] tmpArray, int left, int right) {        if(left<right) {            int center = (left+right)/2;            mergeSort(array, tmpArray, left, center);            mergeSort(array, tmpArray, center+1, right);            merge(array,tmpArray,left,center+1,right);        }    }    /**     * 合并相邻的两部分排序好的数组     * @param array 原数组     * @param tmpArray 临时数组，不用每次递归就重新建立临时数组     * @param leftPos 左边开始位置     * @param rightPos 右边开始位置，左边结束位置为leftPos-1     * @param rightEnd 右边结束位置     */    public void merge(T[] array, T[] tmpArray, int leftPos, int rightPos, int rightEnd ) {        int leftEnd=rightPos-1;        int curPosition=leftPos;        int numElements=rightEnd-leftPos+1;        while(leftPos<=leftEnd && rightPos<=rightEnd) {            if(array[leftPos].compareTo(array[rightPos])<=0)                tmpArray[curPosition++]=array[leftPos++];            else                tmpArray[curPosition++]=array[rightPos++];        }        while(leftPos<=leftEnd)            tmpArray[curPosition++]=array[leftPos++];        while(rightPos<=rightEnd)            tmpArray[curPosition++]=array[rightPos++];        for(int i=0;i<numElements;i++,rightEnd--)            array[rightEnd]=tmpArray[rightEnd];    }

全部源码

全部源码请点击这里，你同样可以在我的博客(点击这里)上看到这篇文章。