排序算法效率比较

排序算法效率比较。编程实现以下几种不同的排序算法（以升序为例）：冒泡排序、选择排序、 希尔排序、快速排序，比较不同的排序过程的运行时间。

具体要求：

• 为了消除数据之间差异导致排序效果的影响，使用相同的数组进行排序，方法为：首先创建一个数组，数组长度至少为100000，数组元素取值范围在[0, 100000]之间的随机正整数，并将这个数组复制4份，分别用不同的排序算法进行排序。

• 记录不同排序算法的运行时间。

• 对完全逆序的情况进行测试，将待排序数组赋值为逆序，即与最终排序要求完全相反。

import java.util.Arrays;
@SuppressWarnings("all")
public class Efficiency_comparison_of_sorting_algorithms {//实验一 比较冒泡排序、选择排序、 希尔排序、快速排序 排序过程的运行时间
    public static void main(String args[]){
        long start = 0;
        long end = 0;
        int []a = new int[100000];
        for(int i = 0;i < a.length; i++){
            a[i] = (int)(Math.random() * 100000);
        }
        int [] array1 = Arrays.copyOf(a,a.length);
        int [] array2 = Arrays.copyOf(a,a.length);
        int [] array3 = Arrays.copyOf(a,a.length);
        int [] array4 = Arrays.copyOf(a,a.length);
        int [] array5 = new int[1000];
        for(int i = 0; i < array5.length; i++){//逆序赋值
            array5[i] = array5.length - i;
        }
        //冒泡排序
        start = System.currentTimeMillis();
        Bubble_sorting(array1);
        end = System.currentTimeMillis();
        System.out.println("冒泡排序用时"+(end - start)+"毫秒");
        System.out.println("-----------------------------------------");

        //选择排序
        start = System.currentTimeMillis();
        Select_sort(array2);
        end = System.currentTimeMillis();
        System.out.println("选择排序用时"+(end - start)+"毫秒");
        System.out.println("-----------------------------------------");

        //希尔排序
        start = System.currentTimeMillis();
        Shell_Sort(array3);
        end = System.currentTimeMillis();
        System.out.println("希尔排序用时"+(end - start)+"毫秒");
        System.out.println("-----------------------------------------");

        //快速排序
        start = System.currentTimeMillis();
        Quick_sort(array4,0,array4.length - 1);
        end = System.currentTimeMillis();
        System.out.println("快速排序用时"+(end - start)+"毫秒");
        System.out.println("-----------------------------------------");

        //逆序测试---------------------------------------------------------------------------------------------

        System.out.println("逆序排序时间测试");
        //冒泡排序逆序
        start = System.currentTimeMillis();
        Bubble_sorting(array5);
        end = System.currentTimeMillis();
        System.out.println("冒泡排序逆序用时"+(end - start)+"毫秒");
        System.out.println("-----------------------------------------");

        //选择排序逆序
        start = System.currentTimeMillis();
        Select_sort(array5);
        end = System.currentTimeMillis();
        System.out.println("选择排序逆序用时"+(end - start)+"毫秒");
        System.out.println("-----------------------------------------");

        //希尔排序逆序
        start = System.currentTimeMillis();
        Shell_Sort(array5);
        end = System.currentTimeMillis();
        System.out.println("希尔排序逆序用时"+(end - start)+"毫秒");
        System.out.println("-----------------------------------------");

        //快速排序逆序
        start = System.currentTimeMillis();
        Quick_sort(array5,0,array5.length - 1);
        end = System.currentTimeMillis();
        System.out.println("快速排序逆序用时"+(end - start)+"毫秒");
        System.out.println("-----------------------------------------");        }

    static void Bubble_sorting(int []a){//冒泡排序
        int temp = 0;
        for(int i = 0;i < a.length;i++){
            for(int j = 0;j < a.length - i - 1;j++){
                if( a[j] > a[j + 1]){
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }

    static void Select_sort(int []a){//选择排序
        int temp = 0;
        for(int i = 0; i <a.length - 1;i++) {
            for(int j = i;j < a.length;j++) {
                if(a[i] > a[j]){
                    temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
    }

    static void Shell_Sort(int []a) {//希尔排序
        int i,j,key,mid;//key作为临时存储变量 mid表示间隔
        for(mid = a.length / 2; mid > 0; mid /= 2){
            for(i = mid; i < a.length; i++){
                j = i;
                key = a[j];
                if (a[j] < a[j - mid]) {
                    while(j - mid >= 0 && a[j - mid] > key){
                        a[j] = a[j - mid];
                        j = j - mid;
                    }
                    a[j] = key;
                }
            }
        }
    }

    static void Quick_sort(int []a,int L,int R){//快速排序
        int left = L;
        int right = R;
        int fir = a[left];
        if(L >= R){
            return;
        }
        while (left < right){//排出一个数左边都比他小，右边都比他大
            while (left < right && a[right] >= fir){//右边找到一个比他小的
                right--;
            }
            if(left < right){
                a[left] = a[right];
            }
            while (left < right && a[left] <= fir){//左边找到一个比他大的
                left++;
            }
            if(left < right){
                a[right] = a[left];
            }
            if(left >= right){
                a[left] = fir;
            }
        }
        Quick_sort(a,L,right - 1);//分组
        Quick_sort(a,right + 1,R);//分组
    }
}