常用排序算法

package newcoder.SortAlgorithm;

import java.util.Random;

public class sortAlgorithm {
    public static void shellSort(int[] array, int len){
        /*
        shell排序
        Shell排序法其实是基于插入排序的方法的原理，进行了改进。
        1、首先将n个元素分成n/2组，第1个数据和第n/2+1个数据为一组
        2、一次循环，将每个序列排序
        3、然后变成n/4组，再一次进行排序
        4、重复上述过程，直到序列减少到1，即形成完整的序列
         */
        long startTime=System.nanoTime();   //获取开始时间
        for(int r=len/2;r>=1;r/=2){
            for(int i=r;i<len;i++){
                int temp = array[i];
                int j = i-r;
                while(j>=0 && array[j]>temp){
                    array[j+r] = array[j];
                    j-=r;
                }
                array[j+r] = temp;
            }
        }
        long endTime=System.nanoTime(); //获取结束时间
        System.out.print("Shell排序后的结果："+"	");
        for(int i=0;i<len;i++){
            System.out.print(array[i]);
            System.out.print(" ");
        }
        System.out.println("	"+"程序运行时间： "+(endTime-startTime)+"ns");
    }
    public static void quickSort(int[] array, int low,int high){
        /*
        快速排序：
        快速排序在于给一个基数寻找其合适的索引位置，
        使得其左边的数据都小于等于它，
        右边的数据大于等于它，
        然后再分别对左边和右边的数据进行快速排序，直到low>=high为止
         */
        if(low>=high){
            return;
        }
        int temp = array[low];
        while(low<high){
            while(high>low && array[high]>=temp){
                high--;
            }
            array[low] = array[high];
            while(high>low && array[low]<=temp){
                low++;
            }
            array[high] = array[low];
            array[low] = temp;
        }
        quickSort(array,0,low-1);
        quickSort(array,low+1,high);

    }
    public static void insertSort(int[] array, int len){
        /*
        插入排序：
        1、首先对数组的前2个数据进行排序
        2、将第3个数据与前2个排序好的数据进行比较，插入到合适的位置
        3、将第4个数据与前3个排序好的数据进行比较，插入到合适的位置
        4、不断重复上述过程，完成最终排序。
         */
        long startTime=System.nanoTime();   //获取开始时间
        for(int i=1;i<len;i++){
            int temp = array[i];
            int j = i-1;
            while(j>=0 && temp<array[j]){
                array[j+1] = array[j];
                j--;
            }
            array[j+1] = temp;
        }
        long endTime=System.nanoTime(); //获取结束时间
        System.out.print("插入排序后的结果："+"	");
        for(int i=0;i<len;i++){
            System.out.print(array[i]);
            System.out.print(" ");
        }
        System.out.println("	"+"程序运行时间： "+(endTime-startTime)+"ns");

    }
    public static void selectSort(int[] array, int len){
        /*
        选择排序：
        在每一步中选择最小的来达到重新排序的
         */
        long startTime=System.nanoTime();   //获取开始时间
        for(int i=0;i<len-1;i++){
            int k = i;
            for(int j=i+1;j<len;j++){
                if(array[j]<array[k]){
                    k = j;
                }
            }
            if(k!=i){
                int temp = array[i];
                array[i] = array[k];
                array[k] = temp;
            }
        }
        long endTime=System.nanoTime(); //获取结束时间
        System.out.print("选择排序后的结果："+"	");
        for(int i=0;i<len;i++){
            System.out.print(array[i]);
            System.out.print(" ");
        }
        System.out.println("	"+"程序运行时间： "+(endTime-startTime)+"ns");

    }
    public static void bubbleSort(int[] array, int len){
        /*
        冒泡排序法：
        核心思想就是比较相邻两个数的大小，然后交换两个数的位置
         */
        long startTime=System.nanoTime();   //获取开始时间
        for(int i=0;i<len;i++){
            for(int j=len-1;j>i;j--){
                if(array[j-1]>array[j]){
                    int temp = array[j-1];
                    array[j-1] = array[j];
                    array[j] = temp;
                }
            }
        }
        long endTime=System.nanoTime(); //获取结束时间
        System.out.print("冒泡排序后的结果："+ "	");
        for(int i=0;i<len;i++){
            System.out.print(array[i]);
            System.out.print(" ");
        }
        System.out.println("	"+"程序运行时间： "+(endTime-startTime)+"ns");



    }
    public static void main(String args[]){
        // 差生随机数组
        Random r= new Random();
        int len = 30;
        int[] array = new int[len];
        for(int i=0;i<len;i++) {
            array[i] = r.nextInt(100);
        }
        System.out.print("随机数组：");
        for(int i=0;i<len;i++){
            System.out.print(array[i]);
            System.out.print(" ");
        }
        System.out.println();
        // 克隆要排序的数组
        int[] bubbleSortArray = array.clone();
        int[] selectSortArray = array.clone();
        int[] insertSortArray = array.clone();
        int[] quickSortArray = array.clone();
        int[] shellSortArray = array.clone();
        // 调用排序函数
        bubbleSort(bubbleSortArray,len);               // 冒泡排序
        selectSort(selectSortArray,len);               // 选择排序
        insertSort(insertSortArray,len);               // 插入排序
        shellSort(shellSortArray,len);                 // shell排序
        long startTime=System.nanoTime();              // 获取开始时间
        quickSort(quickSortArray,0,len-1);   // 快速排序
        long endTime=System.nanoTime(); //获取结束时间
        System.out.print("快速排序后的结果："+"	");
        for(int i=0;i<len;i++){
            System.out.print(insertSortArray[i]);
            System.out.print(" ");
        }
        System.out.println("	"+"程序运行时间： "+(endTime-startTime)+"ns");
    }
}

运行结果：

 关于常用算法的复杂度：