十大排序的Java实现以及横向对比、时间复杂度

一、冒泡排序

两两比较，大的靠后

public class BubbleSorting {
        public static void main(String[] args) {
            int[] numbers=new int[]{1,5,8,2,3,9,4};
            int i,j;
            for(i=0;i<numbers.length-1;i++)
            {
                for(j=0;j<numbers.length-1-i;j++)
                {
                    if(numbers[j]>numbers[j+1])
                    {
                        int temp=numbers[j];
                        numbers[j]=numbers[j+1];
                        numbers[j+1]=temp;
                    }
                }
            }
            System.out.println("从小到大排序后的结果是:");
            for(i=0;i<numbers.length;i++)
                System.out.print(numbers[i]+" ");
        }
    }

总结：冒泡排序结果稳定，但时间长，如果排序的数据量大不建议用冒泡排序。

二、选择排序

第一轮：先选出最小的元素放在首位；
第二轮：除了第一轮确定的最小元素，其他元素继续选最小的放在第一轮最小的后面；
…
以此类推，直至最后一轮选择结束，排序完成

public class SelectionSort {
    public static void main(String[] args) {
        int[] arr={1,3,2,45,65,33,12};
        System.out.println("交换之前：");
        for(int num:arr){
            System.out.print(num+" ");
        }
        //选择排序的优化
        for(int i = 0; i < arr.length - 1; i++) {// 做第i趟排序
            int k = i;
            for(int j = k + 1; j < arr.length; j++){// 选最小的记录
                if(arr[j] < arr[k]){
                    k = j; //记下目前找到的最小值所在的位置
                }
            }
            //在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换
            if(i != k){  //交换a[i]和a[k]
                int temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }
        }
        System.out.println();
        System.out.println("交换后：");
        for(int num:arr){
            System.out.print(num+" ");
        }
    }
}

总结：所需时间和冒泡时间一样，但结果不稳定。

三、插入排序

将一个记录插入到已排好序的序列中，从而得到一个新的有序序列（将序列的第一个数据看成是一个有序的子序列，然后从第二个记录逐个向该有序的子序列进行有序的插入，直至整个序列有序）
动图演示如下：

public class inserSort {
    public static void main(String args[]) {
        int[] array = {4, 2, 7, 3, 5, 4, 0, 45, 16, 36};

        for (int i = 1; i < array.length; i++) {   //默认第零个是有序的
            for (int j = i; j > 0; j--) {          //每次从右边组增加一个数，与左边数据判断，交换位置（左边数据进行排序）
                if (array[j] < array[j - 1]) {
                    int temp = array[j];
                    array[j] = array[j - 1];
                    array[j - 1] = temp;
                }
            }
        }
        for (int n = 0; n < array.length; n++) {
            System.out.println(array[n]);
        }
    }
}

总结：时间复杂度均相同，结果稳定。

四、希尔排序

理解博客：希尔排序
动图演示：