java-排序

一，内部排序

    

   有交换过程的都不稳定，

选择--待排序区选一个最值的出来-交换（不稳定）--不受初始序列顺序影响

    ①简单选择，②堆排序
交换--不停交换，使最值浮现。（不稳定）
    ③冒泡，④快排
插入--取一个待排序，在已排序序列不停比较，找到位置插入
     ⑥直接插入（稳定），⑦折半插入（稳定），⑧希尔排序（不稳定）
归并
    ⑨二路归并，两路插入，（稳定）




O(n^2):简单选择，插入（直接/折半），冒泡
O(n^1.3):希尔排序
O(nlogn)：快排，堆排，二路归并

代码：

/**
 * 内部排序
 *
 *    有交换过程的都不稳定，
 *
 * 选择--待排序区选一个最值的出来-交换（不稳定）
 *     ①简单选择，②堆排序
 * 交换--不停交换，使最值浮现。（不稳定）
 *     ③冒泡，④快排
 * 插入--取一个待排序，在已排序序列不停比较，找到位置插入
 *     ⑥直接插入（稳定），⑦折半插入（稳定），⑧希尔排序（不稳定）
 * ⑨归并
 *      二路归并，两路插入，（稳定）
 *
 *⑩基数排序  (稳定）
 */

//升序
public class InnerSort {
    /**
     * 简单选择，无论有没有序，都要比较n(n-1)/2次，交换次数不确定。最少0次，最多3（n-1）次
     *最好，最坏，平均时间复杂度都为O(n^2)
     */
    public int[] easyChoose(int[] a){
        for(int i=0;i<a.length;i++){
            int index=i;
            for(int j=i+1;j<a.length;j++){
                if(a[j]<a[index]){
                    a[index]=a[j];
                    index=j;
                }
            }
            if(index!=i) swap(i,index,a);
        }
        return a;
    }

    /**
     * 堆排序--小顶堆，每次堆顶与堆尾交换（不稳定），从新调整堆使顶最小。
     *完全二叉树，-跟节点小于子节点a[i]<a[2i].a[i]<a[2i+1]
     * ①建堆
     * ②筛选
     * ③调整
     * 建堆/调整堆--每次找子树的最小节点调到堆顶
     * 新建/调整堆时，low=hign/2
     * 堆排序数组[0]不能用，不满足双亲，2i,2i+1;
     *
     *
     */

    private void sift(int[] a,int low,int high){
        int i=low,j=2*i;
        int top=a[i];
        while(j<=high){
            //拿到i的两个孩子（2i和2i+1）中的较小的
            if(j<high&&a[j]>a[j+1])
                j++;
            if(a[i]>a[j]){//继续往子树遍历，直到找到子树中最小的小标i
                a[i]=a[j];
                i=j;
                j=2*i;
            }
            else break;
        }
        a[i]=top;
    }
    public int[] heapSort(int[] array,int n){
        int i,top;
        //初始堆
        for(i=n/2;i>=1;i--){
            sift(array,i,n);
        }
        //建完堆顶已经最小，直接交换，再排n-1次
        for(i=n;i>=2;i--){
            top=array[1];
            array[1]=array[i];
            array[i]=top;
            sift(array,1,i-1);
        }
        return array;
    }

    /**
     * 冒泡排序-改进版本，若已成序（无交换直接返回）
     * 最好O(n),最坏和平均：O(n^2)
     */
    public int[] bubbleSort(int[] a){
        int i,j;
        boolean exchange;
        for(i=0;i<a.length;i++){
            exchange=false;
            for(j=a.length-1;j>i;j--){
                if(a[j-1]>a[j]){
                    swap(j-1,j,a);
                    exchange=true;
                }
            }
            if(!exchange)return a;
        }
        return a;
    }

    /**
     * 快排,选一个基准值，将小于基准值的放左边，大于基准值的放右边，在对左边和右边快排
     *
     * 时间复杂度平均和最好O(nlogn),最坏O(n^2);
     *
     */
    public int[] quickSort(int[] a,int low,int high){
        int i=low,j=high,num = -1;
        if(low<high){
            num=a[low];
            while(i<j){
                while(j>i&&a[j]>=num)j--;
                while (i<j&&a[i]<=num)i++;
                swap(i,j,a);
            }
            swap(i,low,a);
            quickSort(a,low,i-1);
            quickSort(a,i+1,high);
        }
        return a;
    }

    //直接插入排序,最好O(n),最坏O(n^2),平均O（n^2）
    public int[] easyInseart(int[] a){
        for (int i=1;i<a.length;i++){
            if(a[i]<a[i-1]){
                int j=i-1;
                int num=a[i];
                while(j>=0&&a[j]>num){
                    a[j+1]=a[j];
                    j--;
                }
                a[j+1]=num;
            }
        }
        return a;
    }

    //折半插-二分查找// --查找效率提高，总体交换次数没变，平均时间复杂度O(n^2)
    public int[] binInseart(int[] a){
        for (int i=1;i<a.length;i++){
            if(a[i]<a[i-1]){
                int low=0,high=i-1;
                int num=a[i];
                while(low<=high){
                    int mid=(low+high)/2;
                    if(a[mid]<num)
                        low=mid+1;
                    else
                        high=mid-1;
                }
                for(int j=i-1;j>=high+1;j--)
                    a[j+1]=a[j];
                a[high+1]=num;
            }
        }
        return a;
    }

    /**
     * 希尔排序
     * d=n/2
     * 将排序序列分为d个组，在各组内进行直接插入排序
     * d=d/2,重复第二步，直到d=1;最后一步就是对所有数据进行直接插入排序
     *
     * 平均时间复杂度O（n^1.3）
     */
    public int[] shellSort(int[] a){
        int i,j,d,num;
        d=a.length/2;
        while(d>0){
            for(i=d;i<a.length;i++){
                num=a[i];
                j=i-d;
                while(j>=0&&num<a[j]){
                    a[j+d]=a[j];
                    j=j-d;
                }
                a[j+d]=num;
            }
            d=d/2;
        }
        return a;
    }

    //归并排序---O(nlogn)
    private void merge(int[] a,int low,int mid,int high){
        int[] b = new int[high-low+1];
        int i=low,j=mid+1,k=0;
        while(i<=mid&&j<=high) {
            if (a[i] <= a[j])
                b[k++] = a[i++];
            else
                b[k++] = a[j++];
        }
        while(i<=mid)
            b[k++]=a[i++];
        while(j<=high)
            b[k++]=a[j++];
        for(k=0,i=low;i<=high;k++,i++)
            a[i]=b[k];
    }
    public int[] mergeSort(int[] a,int low,int high){
        if(low<high){
            int mid=(low+high)/2;
            mergeSort(a,low,mid);
            mergeSort(a,mid+1,high);
            merge(a,low,mid,high);
        }
        return a;
    }

    /**
     * 基数排序
     * 不用比较关键字大小，
     */

    //交换函数
    private void swap(int a,int b,int[] c){
        int num=c[a];
        c[a]=c[b];
        c[b]=num;
    }
    //输出数组
    private void printArray(int[] a){
        System.out.print("数组：");
        for(int i=0;i<a.length;i++){
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }


    public static void main(String args[]) {
        InnerSort sort=new InnerSort();
        int[] array={8,4,6,9,22,5,2,16,7,38,26};
        sort.printArray(array);
        //array=sort.easyChoose(array);

//        array=sort.bubbleSort(array);

//        array=sort.quickSort(array,0,array.length-1);

//        array=sort.easyInseart(array);

//        array=sort.binInseart(array);

//        array=sort.shellSort(array);

        array=sort.mergeSort(array,0,array.length-1);



        sort.printArray(array);


//        int[] array1={0,8,4,6,9,22,5};
//        sort.printArray(array1);
//        array1=sort.heapSort(array1,array.length);
//        sort.printArray(array1);


    }
}

二，外部排序

      

 ①生成初始归并段：

1.1，普通方法，按内存大小，将文件分成若干子文件，长度基本相等，个数=N/w  (记录数/工作区容量)

1.2，置换-选择算法，可以减少初始归并段数量，但各归并段长度较大，

 

②多路归并    败者树，--减少关键字比较次数

                      最佳多路归并：最短K叉哈夫曼树