排序算法源码及效率分析汇总

一、各种排序源码

　　闲来无聊，把各种排序的源码写了一遍，如下

    /*
     * 选择排序：
     * 1.取出最小数，与第一个数交换
     * 2.取出剩余部分的最小数，与第二个数交换，并依次迭代
     */
    public Integer[] select_Sort(Integer[] arr){

        for(int i=0;i<arr.length;i++){
            int min=i;
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]<arr[min]) 
                    min=j;
            }
            exchange(arr, i, min);
            printArray(arr);
        }
        return arr;
    }

    /*
     * 冒泡排序
     * 1.临近的数两两比较，按照从小到大的顺序交换位置
     */
    public void bubbleSort(int[] arr) {
      boolean swapped = true;
      int j = 0;
      int tmp;
      while (swapped) {
            swapped = false;
            j++;
            for (int i = 0; i < arr.length - j; i++) {                                       
                  if (arr[i] > arr[i + 1]) {                          
                        tmp = arr[i];
                        arr[i] = arr[i + 1];
                        arr[i + 1] = tmp;
                        swapped = true;
                  }
            }                
      }
}

    /*
     * 插入排序
     * 1.依次遍历数组中的数，确保遍历过的数有序（局部有序）
     */
    public Integer[] insert_Sort(Integer[] arr){

        for(int i=0;i<arr.length;i++){
            for(int j=i;j>0;j--){
                if(arr[j]<arr[j-1]){
                    exchange(arr, j, j-1);
                }
            }
            printArray(arr);
        }
        return arr;
    }

    /*
     * 归并排序
     * 1.分别递归地使左半边、右半边有序,divide()
     * 2.通过归并操作，讲左边、右边有序数组合并成一个有序数组,mergeArray()
     * 3.需要一个辅助数组,保存原始数组;divide()时只对索引操作,mergeArray()时才从aux移动元素到arr
     */
    Integer[] aux;
    public Integer[] merge_Sort(Integer[] arr){
        aux = new Integer[arr.length];
        divide(arr, 0, arr.length-1);

        return arr;
    }
    private void divide(Integer[] arr,int first,int last){
        if(last<=first) return;

        int mid = (last-first)/2 + first;
        divide(arr,first,mid);
        divide(arr, mid+1, last);//这里注意是mid+1,不是mid,不然就死循环了
        mergeArray(arr, first,mid, last);
    }
    private void mergeArray(Integer[] arr,int first,int mid,int last){
        int i= first,j=mid+1;

        for(int p=0;p<arr.length;p++)
            aux[p]=arr[p];

        for(int k=first;k<=last;k++)
            if(j>last)              arr[k] = aux[i++];
            else if(i>mid)          arr[k] = aux[j++];
            else if(aux[i]>aux[j])  arr[k] = aux[j++];
            else                    arr[k] = aux[i++];
        printArray(arr);
    }

    /*
     * 希尔排序
     * 1.按一定步长gap,将数组分为length/gap组，分别对各组进行插入排序
     * 2.迭代缩小gap，并对各组进行插入排序,终止条件是gap>=1
     */

    public Integer[] shell_Sort(Integer[] arr){
       int gap = arr.length / 2;   //分成两组

       while (gap >= 1) {
            // 把距离为 gap 的元素编为一个组，扫描所有组
            for (int i = gap; i < arr.length; i++) {
                int j = 0;
                int temp = arr[i];

                // 对距离为 gap 的元素组进行排序
                for (j = i - gap; j >= 0 && temp < arr[j]; j = j - gap){
                    arr[j + gap] = arr[j];
                }
                arr[j + gap] = temp;
            }
            gap = gap / 2; //减小增量
        }
        return arr;
    }

    /*
     * 快速排序
     * 1.取基准：先从数列中取出一个数作为基准数,返回基准数的索引
       2.分区：将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
       3.依次迭代
     */
    public Integer[] quick_Sort(Integer[] arr){

        _quicksort(arr,0,arr.length-1);
        return arr;
    }

    private void _quicksort(Integer[] arr,int low,int high){

        if(low>=high) return;
        int mid = partition(arr, low, high);

        _quicksort(arr, low, mid-1);
        _quicksort(arr, mid+1, high);
    }
    private int partition(Integer[] arr,int low,int high){

           int i = low, j = high+1;  
           int baseline = arr[low]; //s[l]即s[i]就是第一个坑  
           while (true)  {
                while(arr[++i]<baseline) 
                    if(i==high) break;

                while(baseline<arr[--j]) 
                    if(j==low)  break;

                if(i>=j) break;
                exchange(arr, i, j);
                printArray(arr);
            }  
            exchange(arr, low, j);
            printArray(arr);
            return j;  
    }


    public Integer[] heap_Sort(Integer[] arr){
        //马上更新......
        return arr;
    }
    public Integer[] binaryTree_Sort(Integer[] arr){
        //马上更新......
        return arr;
    }

    private void exchange(Comparable[] a,int i,int j){
        Comparable tmp = a[i];
        a[i]=a[j];
        a[j]=tmp;
    }
    public void printArray(Comparable[] arr){
        System.out.println();
        for(Comparable key:arr){
            System.out.print(key);
            System.out.print("\t");
        }
    }

二、各种算法效率分析

　　马上更新……