java基础算法--排序大全

package sorting;

import java.util.*;
//import java.util.Comparator;
//import java.util.PriorityQueue;
//import java.util.Queue;

public class Sorting {
    /************************************序言**********************************************/
    /**
     * 排序方法：冒泡排序，插入排序，希尔排序，堆排序(2)，归并排序(2)，快排(2)...
     * */
    
    /**
     * 最小值函数
     * */
    private static <AnyType extends Comparable<? super AnyType>> AnyType min(AnyType a, AnyType b){
        if(a.compareTo(b) <= 0)
            return a;
        else 
            return b;
    }
    
    /**
     * 交换函数
     * */
    private static <AnyType extends Comparable<? super AnyType>> void swap(AnyType [] a, int m, int n){
        AnyType tmp = a[n];
        a[n] = a[m];
        a[m] = tmp;        
    }
    /**********************************BubleSort*****************************************/
    /**
     * 冒泡排序：BubleSort
     * 每次内层循环最大的都被滤到最后
     * */
    public static <AnyType extends Comparable<? super AnyType>> void bubleSort(AnyType [] a){
        for(int i=0;i<a.length;i++){  
            for(int j=0;j<a.length-1-i;j++){  
                if(a[j].compareTo(a[j+1]) > 0){   //如果后一个数小于前一个数交换  
                    AnyType tmp=a[j];  
                    a[j]=a[j+1];  
                    a[j+1]=tmp;  
                }  
            }  
        }             
    }
    /*************************SelectSort*************************************************/
    /***
     * 选择排序：SelectSort
     * 每次内层循环最小的被滤到最前
     */
     public static <AnyType extends Comparable<? super AnyType>> void selectSort(AnyType[] a) {
            int minIndex;     
            for (int i = 0; i < a.length; i++) {
                minIndex = i;                
                for (int j = i + 1; j < a.length; j++) {                   
                    if ((a[j].compareTo(a[minIndex])) < 0) {
                        minIndex = j;
                    }
                }                
                swap(a, i, minIndex);
            }
        }

    /*************************InsertionSort**********************************************/    
    /***
     * 插入排序：InsertionSort 
     * @param a
     * 插入排序的实质是从a[1]~a[a.length-1]开始，逐个比较a[p]（p=1,2,...,a.length-1）与a[j-1]的值，直至找到a[p]的位置。
     */     
    public static <AnyType extends Comparable<? super AnyType>> void insertionSort(AnyType [] a){
        int j;
        for(int p = 1; p < a.length; p++){
            AnyType tmp = a[p]; //务必使用tmp变量，否则可能第一轮比较过后啊a[p]也即a[j]的值被覆盖
            for(j = p; j > 0 && tmp.compareTo(a[j - 1])<0;j--){//等于就不挪了，省一次操作
                a[j] = a[j-1];
            }
            a[j] = tmp;
            
        }
    }
    /*************************ShellSort**********************************************/
    /**
     * 希尔排序：ShellSort 最坏情形:O(N2)
     * @param a
     * 希尔排序（即间隔排序）的作用：对于间隔k，希尔排序即对k个独立的子数组的一次插入排序
     */
    public static <AnyType extends Comparable<? super AnyType>> void shellSort(AnyType [] a){
        int j;
        for(int gap = a.length / 2; gap > 0; gap /= 2 ){
            //同时对k个子数组进行间隔排序，相当于和并单独子数组排序的两个for循环 for(int i=0;i<gap;i++){for(int p=i;i<a.length;p+=gap){}}
            for(int i = gap;i < a.length;i++){
                //每个子数组的插入排序
                AnyType tmp = a[i];
                for(j = i;j >= gap && tmp.compareTo(a[j-gap])<0;j-=gap){//等于就不挪了，省一次操作
                    a[j] = a[j-gap];
                }
                a[j] = tmp;
            }
        }
    }
    /*************************HeapSort**********************************************/
    /**
     * 堆排序：HeapSort1   最坏情形:O(Nlog(N)) 堆排序要比希尔排序要慢
     * @param a
     * 堆排序使用优先队列java.util.PriorityQueue实现
     */        
    public static <AnyType extends Comparable<? super AnyType>> void heapSort1(AnyType [] a){
        Comparator<AnyType> comparator = new Comparator<AnyType>(){
            public int compare(AnyType left, AnyType right){
                return left.compareTo(right) ;
             }
        };
        Queue<AnyType> heap = new PriorityQueue<AnyType>(a.length,comparator);
        for(AnyType e:a){
            heap.add(e);
        }
        int i = 0;
        while(!heap.isEmpty()){
            a[i++] = heap.poll();
        }        
    }
    /****************************************************************************************/
    /**
     * 堆排序：HeapSort2 最坏情形:O(Nlog(N))
     * @param a
     * 使用基础代码实现，建堆，排序
     */
    /**
     * 求左子节点
     * */
    private static int leftChild(int i){
        return 2 * i + 1;
    }
    /**
     * 下滤函数：deleteMin(deleteMax)时候使用
     * 对于大根堆下滤期间，大数被逐次滤上去（一步一步），小数被一直滤到它该到的位置（for结束后）
     * @param a 堆数组
     * @param i 开始下滤的起点
     * @param n 堆的有效数组长度，随着不断deleteMax操作，堆中元素会不断减少，有效数组长度n也会逐渐减小
     */
     private static <AnyType extends Comparable<? super AnyType>> void percolateDown(AnyType[] a, int i, int n){
         int child;//左右子中较小的那个节点
         AnyType tmp = a[i];
         
         for(; leftChild(i)< n; i = child){//leftChild(i)< n 判断是否到达最后一个叶子节点
             child = leftChild(i);
             //如果只有一个左子节点，那么不必判断那个更大了
             if(child != n-1 && a[child].compareTo( a[child + 1] ) < 0)//child!=n-1为了确定是否有两个子节点
                 child++;//将两个儿子中大的那个滤上去
             if(tmp.compareTo( a[child]) < 0 ){//等于就不挪了，省一次操作
                 a[i]=a[child];//大数被逐次滤上去（一步一步）
             }else
                 break;
         }
         a[i]=tmp;//小数被for一直滤下来         
     }

    /**
     * 排序结果：升序 ，使用大根堆
     * 建立大根堆，deleteMin操作，得到排序数组
     * 下虑操作：在建立二叉堆和deleteMin中都有使用
     * */
    public static <AnyType extends Comparable<? super AnyType>> void heapSort2(AnyType [] a){
        /*  在无序数组上直接下滤建立大根堆
         *  从低向上开始下滤，即最后一个节点的父节点下滤即a[length/2]
         *  堆从数组索引0开始，因此左子节点为2*i+1,右子节点为2*i+2  
         *  */
        for(int i = a.length/2; i >= 0; i--){
            percolateDown(a, i, a.length);
        }
        /*  堆排序：不断deleteMax将堆中最大的元素放置于数组a的末端
         *  */
        for(int j = a.length-1; j >= 0; j--){
            //deleteMax
            AnyType tmp = a[j];
            a[j] = a[0];
            //将队尾元素放置堆根处，开始下滤
            a[0] = tmp;
            percolateDown(a, 0, j);//初始时刻j为a.length-1
        }
    }
    /*************************MergeSort**********************************************/
    /**
     * 归并排序：MergeSort1  最坏运行时间O(Nlog(N)) 对空间有要求，线性内存    比较次数最少
     * 注意： 归并排序严重依赖于比较元素和数组中移动元素的相对开销，是语言相关的。
     *               其中：java中，执行一次泛型排序（Comparator）时 ，比较（不容易内嵌，动态调度）的的开销要大于移动元素（引用赋值）；由于比较次数最少，是标准java类库中泛型排序所使用的算法。
     *     而 C++则相反，其泛型排序中如果对象庞大，拷贝对象开销大，比较相对省时。C++库中使用快速排序方法。
     * @param a
     * 实现方式：递归，本质就是一直讲待排序的数组二分下去，直至每一半均只有一个元素然后依次合并，完成排序。
     * */
    
    /**
     * 实际完成归并排序的过程的程序
     * */
    private static <AnyType extends Comparable<? super AnyType>> void merge(AnyType [] a, AnyType [] tmpArray, int leftPos, int rightPos, int rightEnd){
        int leftEnd = rightPos - 1;
        int tmpPos = leftPos;
        int numElements = rightEnd - leftPos + 1;
        
        while(leftPos <= leftEnd && rightPos <= rightEnd){
            if(a[leftPos].compareTo(a[rightPos]) <= 0)//等不等于都得拷贝
                tmpArray[tmpPos++] = a[leftPos++];
            else
                tmpArray[tmpPos++] = a[rightPos++];
        }        
        while(leftPos <= leftEnd){
            tmpArray[tmpPos++] = a[leftPos++];
        }
        while(rightPos <= rightEnd){
            tmpArray[tmpPos++] = a[rightPos++];
        }
        for(int i = numElements; i >0; i--){
            a[rightEnd] = tmpArray[rightEnd];
            rightEnd--;//注意rightEnd要单独拿出来自减，否则在上个语句中会自减两次
        }
    }
    
    /**
     * 主递归程序
     * */
    private static <AnyType extends Comparable<? super AnyType>> void mergeSort(AnyType [] a, AnyType [] tmpArray, int left, int right){
        if(left < right){
            int center = (left + right)/2;
            mergeSort(a, tmpArray, left, center);
            mergeSort(a, tmpArray, center + 1, right);
            merge(a, tmpArray, left, center + 1, right);//实际完成排序过程
        }
    }
    
    /**
     * 归并排序驱动程序
     * */
    public static <AnyType extends Comparable<? super AnyType>> void MergeSort1(AnyType [] a){
        AnyType [] tmpArray = (AnyType[]) new Comparable[a.length];
        mergeSort(a, tmpArray, 0, a.length - 1);
    }    
    
    /********************************************************************************/
    /**
     * 归并排序：MergeSort2  最坏运行时间O(Nlog(N))
     * @param a
     * 实现方式：非递归，从单个元素开始归并合成小组，然后小组之间归并直至归并成一个完整的数组，依旧使用MergeSort1使用的merge函数
     * */    
    public static <AnyType extends Comparable<? super AnyType>> void MergeSort2(AnyType [] a){
        int n = a.length;
        AnyType[] tmpArray = (AnyType[]) new Comparable[n]; 
        for(int subList = 1; subList < n; subList *=2){
            int leftPos = 0;
            while(leftPos + subList < n){
                int rightPos = leftPos + subList;
//                int leftEnd = rightPos - 1;
                int rightEnd = min(n-1, rightPos + subList - 1); //一定要注意不能越界 min
                merge(a, tmpArray, leftPos, rightPos, rightEnd);
                leftPos = rightEnd + 1;  //等同于leftPos += 2 * subList;                
            }
        }
    }
    /*************************QuickSort**********************************************/
    /**
     * 快速排序：QuickSort1  平均运行时间：O(NlogN) 最坏运行时间：O(N2)
     * 使用三数中值分割法选取枢纽元
     * 由于对于小数组（N<=20），快速排序的递归会不如插入排序，因此该程序调用插入排序函数。截止范围CUTOFF=10
     * */
    
    
    /**
     * 三数中值分割法：取左端，右端，中心位置的三个元素的中值作为枢纽元
     * 实在值得注意的一点是：三数中值分割法有效的条件是left+2<=right(即至少要有三个元素)的时候才成立，对于2个及2个一下元素将会出现错误。
     * 排序后最小的将位于a[left]，最大的位于a[right]，枢纽元即中间值a[center]将被放置于a[right-1](亦即交换a[center]与a[right-1])
     * 这样在分隔阶段，i,j将从left+1和right-2开始比较
     * 三数中值分割法的好处：a[left]比枢纽元小，将作为j的警戒标记；而a[right-1]存放着枢纽元，则自然作为i的警戒标记。
     * */
    private static <AnyType extends Comparable<? super AnyType>> AnyType median3(AnyType [] a, int left, int right){
        int center = (left +  right)/2;
        if(a[center].compareTo(a[left]) < 0)
            swap(a, center, left);
        if(a[right].compareTo(a[left]) < 0)
            swap(a, right, left);
        if(a[right].compareTo(a[center]) < 0)
            swap(a, right, center);
        //将枢纽元至于a[right - 1]的位置上
        swap(a, center, right - 1);
        return a[right - 1];        
    }
    /**
     * 分割策略
     * */
    private static <AnyType extends Comparable<? super AnyType>> int partition(AnyType [] a, int left, int right){
        AnyType pivot = median3(a, left, right);
        //由于pivot放置在了a[right - 1]的位置(暂存pivot)，因此i,j的取值应该为 left + 1，和right - 2
        int i = left, j = right - 1;
        for(;;){
            //在遇到i,j处值都等于pivot时候停下，但是还得继续道，j<i才算结束，因此while编写要格外注意
            while(a[++i].compareTo(pivot) < 0){}//遇到跟pivot枢纽元值相等的值要停下,否则N2效率低下
            while(a[--j].compareTo(pivot) > 0){}
            if(i < j)
                swap(a, i, j);
            else
                break;                
        }
//        for(;;){
//            while(a[i].compareTo(pivot) < 0){i++;}
//            while(a[j].compareTo(pivot) > 0){j--;}
//            if(i < j){
//                swap(a, i, j);
//                i++;j--;
//            }
//            else
//                break;                
//        }
        swap(a, i, right - 1);
        return i;
    }
    /**
     * 快速排序递归程序，主体程序，遇到跟pivot枢纽元值相等的值要停下
     * 前提条件：left+1<right（即left+2<=right）
     * 实在值得注意的一点是：三数中值分割法有效的条件是left+2<=right(即至少要有三个元素)的时候才成立，对于2个及2个一下元素将会出现错误；
     *                 而这里当CUTOFF设置为1时候，仍旧没有错误的原因是else条件下的insertionSort(a)起了作用
     * */
    private static final int CUTOFF = 10;//CUTOFF>=2
    private static <AnyType extends Comparable<? super AnyType>> void qSort(AnyType [] a, int left, int right){
        //利用截止范围判断数据量
        if(left + CUTOFF <= right){
            //获取枢纽元
//            AnyType pivot = median3(a, left, right);
//            //由于pivot放置在了a[right - 1]的位置(暂存pivot)，因此i,j的取值应该为 left + 1，和right - 2
//            int i = left, j = right - 1;
//            for(;;){
//                //在遇到i,j处值都等于pivot时候停下，但是还得继续道，j<i才算结束，因此while编写要格外注意
//                while(a[++i].compareTo(pivot) < 0){}//遇到跟pivot枢纽元值相等的值要停下,否则N2效率低下
//                while(a[--j].compareTo(pivot) > 0){}
//                if(i < j)
//                    swap(a, i, j);
//                else
//                    break;                
//            }
//            for(;;){
//                while(a[i].compareTo(pivot) < 0){i++;}
//                while(a[j].compareTo(pivot) > 0){j--;}
//                if(i < j){
//                    swap(a, i, j);
//                    i++;j--;
//                }
//                else
//                    break;                
//            }
            //因为i左边都比pivot小，i及i右边除了right-1除存放着pivot外都比pivot大，因此将i处值与right-1处值交换
            //即得到i左边都比其小，右边都比其大，i即pivot排序好的正确位置（换回pivot）
//            swap(a, i, right - 1);
            int i = partition(a, left, right);
            //i已排好序
            qSort(a, left, i - 1);
            qSort(a, i + 1, right);
        }else{
            insertionSort(a);//在这里处理了当CUTOFF等于1时的情景不会出错。当CUTOFF等于0时首先是不允许的（那样left就等于right了），其次这会导致median3()函数数组索引越界异常
            }
    }
    /**
     * 快速排序驱动程序
     * */
    public static <AnyType extends Comparable<? super AnyType>> void quickSort(AnyType [] a){
        qSort(a, 0, a.length - 1);
    }
    
    /*********************************QuickSort2***************************************/
    /**
     * 分割策略
     * */
    private static <AnyType extends Comparable<? super AnyType>> int partition2(AnyType [] a, int start, int end){
        int i = start, j = end;
        AnyType base = a[start];            
        while(i < j ){
            while((a[j].compareTo(base) > 0) && (j > i))
                j--;
            if(i < j){
                a[i] = a[j];
                i++;//
            }
            while((a[i].compareTo(base) < 0) && (i < j))
                i++;
            if(i < j){
                a[j] = a[i];
                j--;//
            }            
                    
        }//while
        a[i] = base;
        return i;
    }
    /**
     * 使用数组第一位作为枢纽元
     * 前提条件：start<end
     * */
    private static <AnyType extends Comparable<? super AnyType>> void qSort2(AnyType [] a, int start, int end){
        if(start < end){
//            int i = start, j = end;
//            AnyType base = a[start];            
//            while(i < j ){
//                while((a[j].compareTo(base) > 0) && (j > i))
//                    j--;
//                if(i < j){
//                    a[i] = a[j];
//                    i++;//
//                }
//                while((a[i].compareTo(base) < 0) && (i < j))
//                    i++;
//                if(i < j){
//                    a[j] = a[i];
//                    j--;//
//                }            
//                        
//            }//while
//            a[i] = base;
            int i = partition2(a, start, end);
            
            qSort2(a, start, i-1);
            qSort2(a, i+1, end);
        }
        
    }
    /**
     * 驱动程序
     * 使用数组第一位作为枢纽元
     * */
    public static <AnyType extends Comparable<? super AnyType>> void quickSort2(AnyType [] a){
        qSort2(a, 0, a.length-1);
    }
    /*********************************QuickSort3***************************************/
    /**
     * 三数中值分割的使用非递归的快速排序
     * */
    public static <AnyType extends Comparable<? super AnyType>> void quickSort3(AnyType [] a){
         if(a==null||a.length<=0)return;  
            Stack<Integer> index=new Stack<Integer>();  
            int start=0;  
            int end=a.length-1;  
              
            int pivotPos;  
                  
            index.push(start);  
            index.push(end);  
                  
            while(!index.isEmpty()){  
                end=index.pop();  
                start=index.pop();  
                if(start+1<end){//三数中值必备
                    pivotPos=partition(a,start,end); 
                    
                    if(start<pivotPos-1){  
                        index.push(start);  
                        index.push(pivotPos-1);  
                    }  
                    if(end>pivotPos+1){  
                        index.push(pivotPos+1);  
                        index.push(end);  
                     
                    }
                }else{//三数中值必备
                    if(a[start].compareTo(a[end])>0)
                        swap(a, start, end);
                }
            }     
    }
    /*********************************QuickSort4***************************************/
    /**
     * 使用第一值为枢纽元的使用非递归的快速排序
     * */
    public static <AnyType extends Comparable<? super AnyType>> void quickSort4(AnyType [] a){
         if(a==null||a.length<=0)return;  
            Stack<Integer> index=new Stack<Integer>();  
            int start=0;  
            int end=a.length-1;  
              
            int pivotPos;  
                  
            index.push(start);  
            index.push(end);  
                  
            while(!index.isEmpty()){  
                end=index.pop();  
                start=index.pop();  
//                if(start<end){  //可有可无，因为压栈的时候已能确定start<end，此处判断是恒成立的
                    pivotPos=partition2(a,start,end); 
                    
                    if(start<pivotPos-1){  
                        index.push(start);  
                        index.push(pivotPos-1);  
                    }  
                    if(end>pivotPos+1){  
                        index.push(pivotPos+1);  
                        index.push(end);  
                     
                    }
//                }
            }     
    }

    /*-----------------------------------------main-------------------------------------------------*/
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /**
         * Test case: Sort the array.
         * */        
//        Integer[] a ={3,1,4,1,5,9,111,2,6,142,543,123,65,453,123,879,572,434,111,242,811,102};
        Integer[] a ={3,1,4,1,5,9,2,6};
        System.out.println("Before sorting:");
        for(Integer i:a){
            System.out.print(i+",");
        }
        System.out.println();
        
        Sorting.quickSort4(a);//排序方法调用
        System.out.println("After sorting:");
        for(Integer i:a){
            System.out.print(i+",");
        }
        System.out.println();

        
    }

}