常用排序算法

一、冒泡排序

原理：比较两个相邻的元素，较大的放在右边

N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次

最好时间复杂度为O(N)

Cmax = N(N-1)/2 = O(N2)
Mmax = 3N(N-1)/2 = O(N2)
冒泡排序的最坏时间复杂度为O(N2)
冒泡排序的平均时间复杂度为O(N2)

 public void bubbleSort(int[] list) {
        int temp = 0; // 用来交换的临时数
        boolean bChange = false; // 交换标志
        // 要遍历的次数
        for (int i = 0; i < list.length - 1; i++) {
            bChange = false;
            // 从后向前依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
            for (int j = list.length - 1; j > i; j--) {
                // 比较相邻的元素，如果前面的数大于后面的数，则交换
                if (list[j - 1] > list[j]) {
                    temp = list[j - 1];
                    list[j - 1] = list[j];
                    list[j] = temp;
                    bChange = true;
                }
            }
            // 如果标志为false，说明本轮遍历没有交换，已经是有序数列，可以结束排序
            if (false == bChange)
                break;
        }
    }

二、快速排序

 通过一趟排序将要排序的数据分割成独立的两部分：分割点左边都是比它小的数，右边都是比它大的数。

 时间复杂度：最好情况（待排序列接近无序）时间复杂度为O(nlog2n)，最坏情况（待排序列接近有序）时间复杂度为O(n2)，平均时间复杂度为O(nlog2n)。

/**

• @description: 快速排序
• 72 6 57 88 70 42 83 73 48 85 （10个元素）
• 首先取第一个数为基准数：72
• 初始时，i = 0, j = 9; X = a[i] = 72
• 这个时候由于将 a[0] 中的数保存到 X 中，相当于数组 a[0] 上挖了一个坑，现需要用其他数据把它填充
• 从 j(后) 开始向前找一个比 X 小或者等于 X 的数。
• 当 j=8 ,符合上述条件，此时将 a[8] 挖出来填充到上一个坑a[0]中。 a[0] = a[8]
• 现在又形成了一个新坑 a[8] ,再次找数字填充a[8]
• 此时要从 i(前) 往后找大于 X 的数
• 当 i= 3 时，符合上述条件，将 a[3] 挖出来填充到 a[8]。 a[8] = a[3]
• (此时的十个数据是 48 6 57 坑 70 42 83 73 88 85）
• 现在是 i = 3; j = 7; X = 72
• 重复之前的步骤，先从后往前找，再从前往后找
• 从 j 开始往前找，当 j = 5,符合之前条件，将 a[5] 填充到 a[3]。 a[3] = a[5]
• 再从 i 开始往后找， 当 i = 5 时， i == j 退出。
• (此时的十个数据是 48 6 57 42 70 72 83 73 88 85）
• @author: mhSui
• @date: 2021-08-17
  */

public class QuickSort {
    public static int partition(int[] list, int start, int end){
        //list[start] 就是第一个坑，也就是基准数
        int key = list[start];
        while (start < end){
            //首先从后往前找小于 X 的数填充 list[start]
            while (start < end && list[end] >= key){
                end--;
            }
            list[start++] = list[end];
            //在从前往后找大于 X 的数
            while (start < end && list[start] < key){
                start++;
            }
            list[end--] = list[start];
        }
        list[start] = key;
        return start;
    }
    public static void quickSort(int[] list, int start, int end){
        int pivot=0;
        if(start < end) {
            pivot=partition(list,start,end);
            //递归调用
            quickSort(list,start,pivot-1);
            quickSort(list,pivot+1,end);
        }
    }
    public static void main(String[] args) {
        QuickSort quickSort = new QuickSort();
        int arr[]= {72,6,57,88,70,42,83,73,48,85};
        System.out.println("排序前："+ Arrays.toString(arr));
        quickSort.quickSort(arr,0,arr.length-1);
        System.out.println("排序后："+Arrays.toString(arr));
    }
}

三、二分查找法

  这里我就直接贴Java里面二分查找的源码Arrays.binarySearch(）

 // Like public version, but without range checks.
    private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

四、选择排序

 选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从  剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。

/**
 * @description: 选择排序
 * @author: stoneshi
 * @date: 2021-08-17
 */
public class SelectSort {
    public  static void selectSort(int[] arr,int length){
        for (int i = 0;i < arr.length;i++){
            int index = i;
            int j;
            //找出最小元素下标
            for (j = i + 1;j < length; j++){
                if (arr[j] < arr[index]) {
                    index = j;
                }
            }
            int temp = arr[index];
            arr[index] = arr[i];
            arr[i] = temp;
        }
    }
}

五、插入排序

 每次处理就是将无序的数列中第一个元素与有序数列的元素从后到前比较，找到插入位置，将该元素插入到有序数列的适当的最终的位置上（稳定排序）。
 空间：仅需要一个辅助空间，为O(1)
 时间：对数列进行升序排列，最好情况——已经是升序了，比较次数为（n-1）次；最坏情况——已经是降序了，比较次数为（n-1）*n/2，赋值操作为（n-1）*n/2 + （n-     1）。
 平均来说插入排序算法复杂度为O(n2)。因而，插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，例如，量级小于千，那么插入排序还是一个不错的选择。 插入排序在工业级库中也有着广泛的应用，在STL的sort算法和stdlib的qsort算法中，都将插入排序作为快速排序的补充，用于少量元素的排序（通常为8个或以下）

/**
 * @description: 插入排序
 * @author: stoneshi
 * @date: 2021-08-17
 */
public class InsertSort {

    private static void insertSort(int[] arr){
        for (int i = 0; i < arr.length; i++){
            // arr[i] 在arr[0...length-1]有序区间找到合适位置
            int temp = arr[i];
            int j = i-1;
            while(j >= 0 && arr[j] > temp){
                arr[i+1] = arr[j];
                j = j-1;
            }
            arr[j+1] = temp;
        }
    }
}