java：排序算法

selection排序

import java.util.*;
import java.util.Comparator;

public class Solution {
    private Solution(){} //初始化函数

    public static void sort(Comparable[] a){
        //a是升序排列
         int N=a.length;
         for(int i=0;i<N;i++){
             int min=i; //最小元素的索引
             for(int j=i+1;j<N;j++)
                 if(less(a[j],a[min])<0)
                     min=j;
             exch(a,i,min);
         }
    }

    private static int less(Comparable v,Comparable w){
        return v.compareTo(w);
    }

    private static void exch(Comparable[] a, int i, int j){
        Comparable t=a[i];a[i]=a[j];a[j]=t;
    }
    private static void show(Comparable[] a){
        for(int i=0;i<a.length;i++)
            System.out.println(a[i]+" ");
        System.out.println(" ");
    }
    public static boolean isSorted(Comparable[] a){
        //  测试元素是否有序
        for(int i=1;i<a.length;i++)
            if(less (a[i],a[i-1]))
                return false;
        return true;
    }
    public static void main(String[] args)
    {

        Scanner cin=new Scanner(System.in);
        int n=cin.nextInt();
        Integer[] temp= new Integer[n];
        for(int i=0;i<n;i++)
            temp[i]=new Integer(cin.nextInt());
        Comparable[] a=new Comparable[n];

        for(int i=0;i<n;i++)
        {

            a[i]=temp[i];
        }
        sort(a);
        assert isSorted(a);
        show(a);

    }

}

• 插入排序（O(n) ~O（n*n））

  左边有序，右边位置后移

public static void sort(Comparable[] a){
        //a是升序排列
        int N=a.length;
        for(int i=1;i<N;i++)
            // 将a[i]插入a[i-1],a[i-2],.... 之中
        {
            for(int j=i;j>0 && less(a[j],a[j-1]);j--)
                exch(a,j,j-1);
        }
    }

希尔排序

任意间隔h的元素都是有序

public static void sort(Comparable[] a){
        //a[]升序
        int N=a.length;
         int h=1;
         while(h<N/3) h=3*h+1; //1,4,13,40...
         while(h>=1){
             // 将数组变成h有序
              for(int i=h;i<N;i++){
                  //a[i]插入到a[i-h],a[i-2*h],a[i-3*h],....
                  for(int j=i; j>=h && less(a[j],a[j-h]);j-=h){
                      exch(a,j,j-h);
                  }
                  h=h/3;

              }

         }
    }

归并排序

时间：NlgN

空间：N

import java.util.*;
import java.util.Comparator;

public class Solution {
    private Solution(){} //初始化函数

    private static Comparable[] aux; // 辅助数组
    public static void merge(Comparable[] a,int lo,int mid,int hi){
        //将a[lo..mid]和a[mid+1,..,hi]

        int i=lo,j=mid+1;

        for(int k=lo;k<=hi;k++) //将a[lo..hi]复制到aux[lo..hi]
            aux[k]=a[k];

        for(int k=lo;k<=hi;k++){
            if(j>mid) a[k]=aux[j++];  //[j++]=[j]，然后j++
            else if (j>hi) a[k]=a[i++];
            else if (less(aux[j],aux[i])) a[k]=aux[j++];
            else a[k]=aux[i++];
        }
    }

    //自顶向下递归

    public static void sort(Comparable[] a) //归并所需要排序的数组
    {
        aux=new Comparable[a.length]; //一次性分配空间
        sort(a,0,a.length-1);
    }

    private static void sort(Comparable[] a,int lo,int hi){
        //将数组a[lo...hi] 排序
        if(hi<=lo) return;
        int mid=lo+(hi-lo)/2;
        sort(a,lo,mid); // 左边排序
        sort(a,mid+1,hi); //右边排序
        merge(a,lo,mid,hi);  // 归并结果
    }

    private static boolean less(Comparable v,Comparable w){
        if(v.compareTo(w)<=0)
            return true;
        else
            return false;
    }

    private static void exch(Comparable[] a, int i, int j){
        Comparable t=a[i];a[i]=a[j];a[j]=t;
    }
    private static void show(Comparable[] a){
        for(int i=0;i<a.length;i++)
            System.out.println(a[i]+" ");
        System.out.println(" ");
    }
    public static boolean isSorted(Comparable[] a){
        //  测试元素是否有序
        for(int i=1;i<a.length;i++)
            if(less (a[i],a[i-1]))
                return false;
        return true;
    }
    public static void main(String[] args)
    {

        Scanner cin=new Scanner(System.in);
        int n=cin.nextInt();
        Integer[] temp= new Integer[n];
        for(int i=0;i<n;i++)
            temp[i]=new Integer(cin.nextInt());
        Comparable[] a=new Comparable[n];

        for(int i=0;i<n;i++)
        {

            a[i]=temp[i];
        }
        sort(a);
        assert isSorted(a);
        show(a);

    }

}

• 非递归代码

自底向上的归并

    public static void sort(Comparable[] a) //归并所需要排序的数组
    {
        //进行lgn次两两归并
        int N=a.length;
        aux=new Comparable[N];
        for(int sz=1;sz<N;sz=sz+sz) // sz子数组的大小
            for(int lo=0;lo<N-sz;lo+=sz+sz){
                merge(a,lo,lo+sz-1,Math.min(lo+sz+sz-1,N-1));
            }

    }

快速排序

时间复杂度：NlgN

空间复杂度：lgN

• 基本快速

import java.util.*;
import java.util.Comparator;

public class Solution {
    private Solution(){} //初始化函数

    public static void sort(Comparable[] a){
        // StdRandom.shuffle(a);//打乱数组  // 保持随机性，或者随机选择数组
        sort(a,0,a.length-1);

    }

    private static void sort(Comparable[] a,int lo,int hi){
        if(lo<hi) return;
        int j=partition(a,lo,hi); //切分函数
        sort(a,lo,hi);//  将左半部分排序 a[low,j-1]
        sort(a,j+1,hi); //将右半部分排序 a[j+1,hi]
    }

    //  切分函数，选择a[lo] 为切分值
    private static int partition(Comparable[] a,int lo,int hi){
        int i=lo,j=hi+1; //左右扫描指针
        Comparable v=a[lo]; //切分元素
        while(true){
            //左右扫描，检查扫描是否结束，交换元素
            while(less(a[++i],v)) if(i==hi) break;
            while(less(v,a[--j])) if(j=lo) break;
            if(i>=j) break;
            exch(a,lo,j);
        }
        exch(a,lo,j); //将v=[j] 放入正确位置
        return j;
    }

    private static boolean less(Comparable v,Comparable w){
        if(v.compareTo(w)<=0)
            return true;
        else
            return false;
    }

    private static void exch(Comparable[] a, int i, int j){
        Comparable t=a[i];a[i]=a[j];a[j]=t;
    }
    private static void show(Comparable[] a){
        for(int i=0;i<a.length;i++)
            System.out.println(a[i]+" ");
        System.out.println(" ");
    }
    public static boolean isSorted(Comparable[] a){
        //  测试元素是否有序
        for(int i=1;i<a.length;i++)
            if(less (a[i],a[i-1]))
                return false;
        return true;
    }
    public static void main(String[] args)
    {

        Scanner cin=new Scanner(System.in);
        int n=cin.nextInt();
        Integer[] temp= new Integer[n];
        for(int i=0;i<n;i++)
            temp[i]=new Integer(cin.nextInt());
        Comparable[] a=new Comparable[n];

        for(int i=0;i<n;i++)
        {

            a[i]=temp[i];
        }
        sort(a);
        assert isSorted(a);
        show(a);

    }

}

• 改进的快速排序

堆排序

• 建堆时间：o(n)
• 调整堆：O（lgn）
• 复杂度：O（nlgn）

import java.util.*;
import java.util.Comparator;

public class Solution {
    private Solution(){} //初始化函数

    public static void sort(Comparable[] a)
    {
        int N=a.length;
        for(int k=N/2;k>=1;k--)
            sink(a,k,N);// 下沉（由上而下的堆得有序化）// 构建了堆
        while(N>1){
            exch(a,1,N--);
            sink(a,1,N);
        }
    }

    private static void sink(Comparable[] a,int k, int N)
    {
        while(2*k<=N){
            int j=2*k;
            if(j<N && less(a,j,j+1))
                j++;
            if(!less(a,k,j))  break;
            exch(a,k,j);
            k=j;
        }
    }

    private static boolean less(Comparable[] a,int i,int j){
        return a[i-1].compareTo(a[j-1])<0;
    }

    private static boolean less(Comparable v,Comparable w){
        if(v.compareTo(w)<=0)
            return true;
        else
            return false;
    }

    private static void exch(Comparable[] a, int i, int j){
        Comparable t=a[i];a[i]=a[j];a[j]=t;
    }
    private static void show(Comparable[] a){
        for(int i=0;i<a.length;i++)
            System.out.println(a[i]+" ");
        System.out.println(" ");
    }
    public static boolean isSorted(Comparable[] a){
        //  测试元素是否有序
        for(int i=1;i<a.length;i++)
            if(less (a[i],a[i-1]))
                return false;
        return true;
    }
    public static void main(String[] args)
    {

        Scanner cin=new Scanner(System.in);
        int n=cin.nextInt();
        Integer[] temp= new Integer[n];
        for(int i=0;i<n;i++)
            temp[i]=new Integer(cin.nextInt());
        Comparable[] a=new Comparable[n];

        for(int i=0;i<n;i++)
        {

            a[i]=temp[i];
        }
        sort(a);
        assert isSorted(a);
        show(a);

    }

}