常用排序算法 java

比较常见的几种排序：

1.冒泡排序，时间复杂度O（n^2）

2.插入排序，时间复杂度O（n^2）

3.希尔排序，由于是跳跃式的，采用Sedgewick增量序列，猜想时间复杂度O（n^4/3）

4.归并排序，时间复杂度O（nlogn）

//冒泡排序
public class test1
{
    public static void main(String[] args) 
    {
        int[] arr=new int[]{6,5,4,3,2,1,0,-1};
        arr=bubbleSort(arr,arr.length);
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]);
        }
    }
    public static int[] bubbleSort(int[] arr,int n)
    {
        for(int j=0;j<n;j++)
        {
            for (int i=0;i<n-j-1 ;i++ )
            {
                if (arr[i]>arr[i+1])
                {
                    int temp=arr[i];
                    arr[i]=arr[i+1];
                    arr[i+1]=temp;
                }
            
            }
        }
        return arr;
    }
}

//插入排序
public class InsertSort {
    public static void main(String[] args)
    {
        int[] arr=new int[]{6,5,4,3,2,1,0,-1};
        arr=insertSort(arr,arr.length);
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]);
        }
    }
    public static int[] insertSort(int[] arr,int n)
    {
        for(int i=1;i<n;i++)
        {
            int current=arr[i];
            for(int j=i;j>0&&current<arr[j-1];j--)
            {
                arr[j]=arr[j-1];
                arr[j-1]=current;
            }
        }
        return arr;
    }
}

//希尔排序
public class ShellSort {
    public static void main(String[] args)
    {
        int[] arr=new int[]{1,2,3,4,5,6,7,9,8};
        arr=shellSort(arr,arr.length);
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]);
        }
    }
    public static int[] shellSort(int[] arr,int n)
    {
        int si=0;
        int d=0;
        //采用Sedgewick增量序列
        int Sedgewick[] = {929, 505, 209, 109, 41, 19, 5, 1, 0};
        //找出补超过数组长度的增量序列最大值
        for(si=0;Sedgewick[si]>n;si++)
        {}
        //增量序列由不超过数组长度的最大值减小到1
        for(d=Sedgewick[si];d>0;d=Sedgewick[++si])
        {
            for(int i=d;i<n;i=i+d)
            {
                int current=arr[i];
                for(int j=i;j>0&&current<arr[j-d];j=j-d)
                {
                    arr[j]=arr[j-d];
                    arr[j-d]=current;
                }
            }
        }
        return arr;
    }
}

//归并排序
public class MergeSort {
    public static void main(String[] args)
    {
        int[] arr=new int[] {9,8,7,6,5,4,3,2,1};
        int n=arr.length;
        arr=mergeSort(arr,n);
        for(int i=0;i<arr.length;i++)
            System.out.print(arr[i]+" ");
    }
    //将两个有序数组合并函数
    public static void merge(int[] arr,int l,int r,int rightEnd)
    {
        int numElements=rightEnd-l+1;
        int[] temp=new int[arr.length];
        int leftEnd=r-1;
        int i=l;
        while(l<=leftEnd&&r<=rightEnd)
        {
            if(arr[l]<=arr[r])
                temp[i++]=arr[l++];
            else
                temp[i++]=arr[r++];
        }
        while(l<=leftEnd)
            temp[i++]=arr[l++];
        while(r<=rightEnd)
            temp[i++]=arr[r++];
        
        for (int j=0;j<numElements;j++,rightEnd--)
            arr[rightEnd]=temp[rightEnd];
    
    }
    //用递归的归并排序
    public static void merge_Sort(int[] arr,int l,int rightEnd)
    {
        int center=(l+rightEnd)/2;
        if(l<rightEnd)
        {
            merge_Sort(arr,l,center);
            merge_Sort(arr,center+1,rightEnd);
            merge(arr,l,center+1,rightEnd);
        }
    }
    //用和其他排序方法统一的接口形式
    public static int[] mergeSort(int[] arr,int n)
    {
        merge_Sort(arr,0,n-1);
        return arr;
    }

}