八大排序算法（java实现）

一.冒泡排序（BubbleSort）

基本思想：两个数比较大小，较大的数下沉，较小的数冒起来。

过程：

比较相邻的两个数据，如果第二个数小，就交换位置。
从后向前两两比较，一直到比较最前两个数据。最终最小数被交换到起始的位置，这样第一个最小数的位置就排好了。

在冒泡排序中第二个for循环，一定要控制两两交换数据的范围。减去已经排好序的范围。

平均时间复杂度：O(n^2)

java代码实现：

 public static void BubbleSort(int[] arr){
        // 每次遍历标志位都要先置为false，才能判断后面的元素是否发生了交换
        boolean flag = false;
        int temp;
        // 表示趟数，一共arr.length-1次。
        for(int i = 0;i < arr.length - 1;i ++){
            flag = false;
            // 选出该趟排序的最小值往前移动
            for(int j = arr.length - 1;j > i;j --){
                if(arr[j] < arr[j - 1]){
                    temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                    // 只要有发生了交换，flag就置为true
                    flag = true;
                }
            }

            // 判断标志位是否为false，如果为false，说明后面的元素已经有序，就直接return
            if(!flag){
                break;
            }
        }

    }

二.选择排序（SelectSort）

基本思想：

在长度为N的无序数组中，第一次遍历n-1个数，找到最小的数值与第一个元素交换；
第二次遍历n-2个数，找到最小的数值与第二个元素交换；
。。。
第n-1次遍历，找到最小的数值与第n-1个元素交换，排序完成。

平均时间复杂度：O(n^2)

java代码实现：

public static void SelectSort(int[] arr){
        for(int i = 0;i < arr.length - 1;i ++){
            int minIndex = i;
            for(int j = i + 1 ;j < arr.length;j ++){
                if(arr[minIndex] > arr[j]){
                    minIndex = j;
                }
            }

            if (minIndex != i){
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }


    }

插入排序（InsertSort）

基本思想：

在要排序的一组数中，假定前n-1个数已经排好序，现在将第n个数插到前面的有序数列中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。

平均时间复杂度：O(n^2)

java代码实现：

 public static void InsertSort(int[] arr){
        int temp = 0;
        for(int i = 0;i < arr.length - 1;i ++){
            for(int j = i + 1;j > 0;j --){
                if(arr[j] < arr[j - 1]){
                    temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j-1] = temp;
                }else {
                    // 不需要交换
                    break;
                }
            }
        }
    }

四.希尔排序（ShellSort）

基本思想：

在要排序的一组数中，根据某一增量分为若干子序列，并对子序列分别进行插入排序。
然后逐渐将增量减小,并重复上述过程。直至增量为1,此时数据序列基本有序,最后进行插入排序。

平均时间复杂度：O(n^2)

java代码实现：

public static void ShellSort(int[] arr){
        int temp = 0;
        int incre = arr.length;

        while (true){
            incre /= 2;
            // 根据增量分为若干子序列
            for(int i = 0;i < incre;i ++){
                for(int j = i + incre;j < arr.length;j += incre){
                    for(int k = j;k > i;k -= incre){
                        if(arr[j] < arr[j - 1]){
                            temp = arr[j];
                            arr[j] = arr[j - 1];
                            arr[j - 1] = temp;
                        }
                    }
                }
            }

            if(incre == 1){
                break;
            }
        }
    }