经典的排序算法java实现版

/**
 * 
 * @author yuzhiping
 * @version 1.0
 * 功能说明:计算机领域经典的算法
 *
 */
public class sortAlgorithm<T extends Comparable<T>> {
    
    //交换索引i和索引j的值
    private void swap(T [] data ,int i,int j){
        T tmp;
        tmp=data[i];
        data[i]=data[j];
        data[j]=tmp;
    }
    
    
    //-----堆排序 时间复杂度O(nlogn)-----
    
    public void heapSort(T [] data){
        int arrayLength=data.length;
        //循环件堆
        for(int i=0;i<arrayLength-1;i++){
            // 建堆
            builMaxdHeap(data, arrayLength - 1 - i);
            // 交换堆顶和最后一个元素
            swap(data, 0, arrayLength - 1 - i);

        }
    }
    
    // 对data数组从0到lastIndex建大顶堆
    private void builMaxdHeap(T[] data, int lastIndex) {
        // 从lastIndex处节点（最后一个节点）的父节点开始
        for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
            // k保存当前正在判断的节点
            int k = i;
            // 如果当前k节点的子节点存在
            while (k * 2 + 1 <= lastIndex) {
                // k节点的左子节点的索引
                int biggerIndex = 2 * k + 1;
                // 如果biggerIndex小于lastIndex，即biggerIndex + 1
                // 代表的k节点的右子节点存在
                if (biggerIndex < lastIndex) {
                    // 如果右子节点的值较大
                    if (data[biggerIndex].compareTo(data[biggerIndex + 1]) < 0) {
                        // biggerIndex总是记录较大子节点的索引
                        biggerIndex++;
                    }
                }
                // 如果k节点的值小于其较大子节点的值
                if (data[k].compareTo(data[biggerIndex]) < 0) {
                    // 交换它们
                    swap(data, k, biggerIndex);
                    // 将biggerIndex赋给k，开始while循环的下一次循环，
                    // 重新保证k节点的值大于其左、右子节点的值。
                    k = biggerIndex;
                } else {
                    break;
                }
            }
        }
    }
     
    //-----冒泡排序法 时间复杂度O(n^2)-----
    public void bubbleSort(T[] data){
        int i,j;
        for(i=0;i<data.length-1;i++){
            for(j=0;j<data.length-i-1;j++){
                if(data[j].compareTo(data[j+1]) > 0){
                    swap(data,j+1,j);
                }
            }
        }
    }
     
    //-----选择排序法 时间复杂度O(n^2)-----
    public void selectSort(T[] data){
        int i,j;    
         
        for(i=0;i<data.length-1;i++){
            for(j=i+1;j<data.length;j++){
                if (data[i].compareTo(data[j]) > 0){
                    swap(data,i,j);
                }
            }
        }
    }
     
    //-----快速排序法  时间复杂度为O(log2n)-----
    public void quickSort(T[] data){
        subQuickSort(data,0,data.length-1);
    }
     
    private void subQuickSort(T[] data,int start,int end){
        if( start < end ){
            //以第一个元素作为分界值
            T base = data[start];
            //i从左边开始搜索大于分界值元素的索引
            int i = start;
            //j从右边开始搜索小于分界值元素的索引
            int j = end + 1;
            while(true){
                //左边跳过比base小的元素
                while(i < end && data[++i].compareTo(base) <= 0);
                //右边跳过比base大的元素
                while(j > start && data[--j].compareTo(base) >= 0);
                 
                if(j > i){
                    swap(data,i,j);
                }else{
                    break;
                }
            }
            //将分界值还原
            swap(data,start,j);
             
            //递归左边序列
            subQuickSort(data,start,j-1);
            //递归右边序列
            subQuickSort(data,j+1,end);
        }
    }
     
    //-----插入排序法 时间复杂度O(n^2)-----
    public void insertSort(T[] data){
        int arrayLength = data.length;
         
        for(int i=1;i<arrayLength;i++){
            //当整体后移时保证data[i]的值不会丢失
            T tmp = data[i];
            //i索引处的值已经比前面所有值都大,表明已经有序,无需插入
            //i-1处索引之前的数值已经有序,i-1处索引处元素的值也是最大值
            if(data[i].compareTo(data[i-1]) < 0){
                int j = i-1;
                //整体后移一个
                while(j>=0 && data[j].compareTo(tmp) > 0){
                    data[j+1] = data[j];
                    j--;
                }
            data[j+1] = tmp;
            }
        }
    }
     
    //-----折半插入排序法 时间复杂度-----
    public void binaryInsertSort(T[] data) {
        int arrayLength = data.length;
 
        for (int i = 1; i < arrayLength; i++) {
            if (data[i - 1].compareTo(data[i]) > 0) {
                // 缓存i处的元素值
                T tmp = data[i];
 
                // 记录搜索范围的左边界
                int low = 0;
                // 记录搜索范围的右边界
                int high = i - 1;
 
                while (high >= low) {
                    // 记录中间位置
                    int mid = (high + low) / 2;
                    // 比较中间位置数据和i处数据大小，以缩小搜索范围
 
                    if (tmp.compareTo(data[mid]) > 0) {
                        low = mid + 1;
                    } else {
                        high = mid - 1;
                    }
                }
                // 将low~i处数据整体向后移动1位
                for (int j = i; j > low; j--) {
                    data[j] = data[j - 1];
                }
                data[low] = tmp;
 
            }
        }
    }
     
    //-----希尔排序法 时间复杂度O(nlogn)O(n^2)具体看h的值-----
    public void shellSort(T[] data){
        int arrayLength = data.length;
        //h保存可变增量
         
        int h = 1;
        while(h<=arrayLength/3){
            h = h * 3 + 1;
        }
         
        while(h > 0){
            //System.out.println(Arrays.toString( data )+"h="+h);
             
            for(int i=h;i<arrayLength;i++){
                //当整体后移时,保证data[i]的值不丢失
                T tmp = data[i];
                //i索引处的值已经比前面所有的值大
                //(i-1索引之前的值已经有序的,i-1索引处元素的值就是最大值)
                if(data[i].compareTo(data[i-h]) < 0){
                    int j = i-h;
                    //整体后移一格
                    while(j>=0 && data[j].compareTo(tmp) > 0){
                        data[j+h] = data[j];
                        j-=h;
                    }
                     
                    //最后将tmp值插入合适的位置
                    data[j+h] = tmp;
                }
            }
            h = (h-1)/3;
        }
         
    }
     
    //-----归并排序法 时间复杂度为O(nlog2n)-----
    public void mergeSort(T[] data){
        subMergeSort(data,0,data.length-1);
    }
     
    private void subMergeSort(T[] data,int left,int right){
        if(right > left){
            //找出中间索引
            //System.out.println(  Arrays.toString(data) );
            int center = (left + right)/2;
            //对左边数组进行递归
            subMergeSort(data,left,center);
            //对右边数组进行递归
            subMergeSort(data,center+1,right);
            //合并
            merge(data,left,center,right);
        }
    }
     
    @SuppressWarnings("unchecked")
    private void merge(T[] data, int left, int center, int right) {
        Object[] tmpArr = new Object[data.length];
        int mid = center + 1;
        // third记录中间处索引
        int third = left;
        int tmp = left;
 
        while (left <= center && mid <= right) {
            // 从两个数组中取出最小的放入中间数组
            if (data[left].compareTo(data[mid]) <= 0) {
                tmpArr[third++] = data[left++];
            } else {
                tmpArr[third++] = data[mid++];
            }
        }
         
        // 剩余部分依次放入中间数组
        while (mid <= right) {
            tmpArr[third++] = data[mid++];
        }
        while (left <= center) {
            tmpArr[third++] = data[left++];
        }
         
        // 将中间数组的内容复制拷回原数组
        // (原left~right范围内德内容被复制回原数组)
        while (tmp <= right) {
            data[tmp] = (T) tmpArr[tmp++];
        }
    }
     


    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

}