常见的几种排序方法

冒泡排序

冒泡排序是把较小的数据往前调或者把较大的数据往后调。主要是通过对相邻两个元素进行大小的比较，根据比较结果和算法规则对该二元素的位置进行交换，这样逐个依次进行比较和交换，就能达到排序目的。

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

 

插入排序

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

//直接插入排序
    public static void insertSort(int[] arr) {
        //从第二个数字开始
        for (int i = 1; i < arr.length; i++) {
            //当前数字小于前一个数
            if (arr[i] < arr[i - 1]) {
                //当前数字保存至临时变量
                int temp = arr[i];
                int j;
                //遍历当前数字之前的所有数字进行比较，是否大于当前数字
                for (j = i - 1; j >= 0 && temp < arr[j]; j--) {
                    //把满足条件的数字向后移位
                    arr[j + 1] = arr[j];
                }
                //不满足条件则表示当前数字比临时变量的数字小
                arr[j + 1] = temp;
            }
        }
    }

 

 

选择排序

选择排序是为每一个位置选择当前最小的元素。首先从第1个位置开始对全部元素进行选择，选出全部元素中最小的给该位置，再对第2个位置进行选择，在剩余元素中选择最小的给该位置即可；以此类推，重复进行“最小元素”的选择，直至完成第(n-1)个位置的元素选择，则第n个位置就只剩唯一的最大元素，此时不需再进行选择。

 //选择排序
    public static void selectSort(int[] arr) {
        //遍历所有元素
        for (int i = 0; i < arr.length; i++) {
            //记录最小值得下标
            int minIndex = i;
            //与后面每个元素进行比较
            for (int j = i + 1; j < arr.length; j++) {
                //如果有元素比minIndex还小
                if (arr[minIndex] > arr[j]) {
                    //则当前元素就位minIndex
                    minIndex = j;
                }
            }
            //如果当前下标和minIndex不相等，说明它比minIndex还小，那么就移位
            if (i != minIndex) {
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }

 

快速排序

通过一次排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一不部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序

 

//快速排序
    public static void QuickSort(int[] arr, int start, int end) {
        //记录基准数
        int stard = arr[start];
        //低位起始下标
        int low = start;
        //高位起始下标
        int higt = end;
        //满足start<end保证数据不会多余重复比较
        if (start < end) {
            //低位下标小于高位下标，开始比较
            while (low < higt) {
                //低位下标小于高位下标,并且高位数大于等于基准数
                while ((low < higt) && stard <= arr[higt]) {
                    //高位数依次向前比较
                    higt--;
                }
                //不满足条件时，当前高位数覆盖当前低位数，第一次覆盖时低位数是基准数
                arr[low] = arr[higt];
                //低位下标小于高位下标,并且低位数小于等于基准数
                while ((low < higt && arr[low] <= stard)) {
                    //低位数依次向后比较
                    low++;
                }
                //不满足条件时，当前低位数覆盖当前高位数
                arr[higt] = arr[low];
            }
            //比较完成后，高位数下标和低位数下标重合，把基准数赋值给重合的位置
            arr[higt] = stard;
            //继续递归排序低位数
            QuickSort(arr, start, low);
            //继续递归排序高位数
            QuickSort(arr, low + 1, end);
        }
    }

 

归并排序

归并排序是把集合递归划分成为两个短集合，再将两个集合各自再分成两组组。依次类推，当分出来的一个集合只有一个数据时，可以认为这个集合内已经达到了有序，然后再合并相邻的二个集合就可以了。这样通过先递归的分解集合，再合并集合就完成了归并排序。

 

 //归并排序
    public static void mergeSort(int[] arr, int low, int high) {
        int middle = (low + high) / 2;
        if (low < high) {
            //处理左边
            mergeSort(arr, low, middle);
            //处理右边
            mergeSort(arr, middle + 1, high);
            //归并
            merge(arr, low, middle, high);
        }
    }

    public static void merge(int[] arr, int low, int middle, int high) {
        //临时数组
        int[] temp = new int[high - low + 1];
        //临时数组下标记录
        int index = 0;
        //第一组需要遍历的起始下标
        int i = low;
        //第二组需要遍历的起始下标
        int j = middle + 1;
        //遍历两个数组，取出最小数放入临时数组
        while (i <= middle && j <= high) {
            if (arr[i] <= arr[j]) {
                temp[index] = arr[i];
                i++;
            } else {
                temp[index] = arr[j];
                j++;
            }
            index++;
        }
        //处理多余的数据
        while (j <= high) {
            temp[index] = arr[j];
            j++;
            index++;
        }
        while (i <= middle) {
            temp[index] = arr[i];
            i++;
            index++;
        }
        //把临时数组中的数据重新放入原数组
        for (int k = 0; k < temp.length; k++) {
            arr[k + low] = temp[k];

        }
    }