几个常用排序：快速排序、归并排序、冒泡排序自己手敲代码（JAVA）并注释

1、快速排序：

利用递归，每次把数组按标记位分为两部分，左边部分所有值小于标记位的值，右边部分所有值大于标记位的值

/**
 * Created by fanxh on 2020/6/30.
 * 快速排序
 * 利用递归，每次把数组按标记位分为两部分，左边部分所有值小于标记位的值，右边部分所有值大于
 * 标记位的值
 */
public class QuickSort {
    public static int[] qsort(int arr[],int start,int end) {
        int pivot = arr[start];
        int i = start;
        int j = end;
        while (i<j) {
            while ((i<j)&&(arr[j]>pivot)) {
                j--;
            }
            while ((i<j)&&(arr[i]<pivot)) {
                i++;
            }
            if ((arr[i]==arr[j])&&(i<j)) {
                i++;
            } else {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        if (i-1>start) arr=qsort(arr,start,i-1);
        if (j+1<end) arr=qsort(arr,j+1,end);
        return arr;
    }

    // 自己手敲代码实现快速排序
    public static int[] myQuickSort(int[] intArray,int min,int max){
        // 用第一个数字作为对比值
        int key = intArray[min];
        int i = min,j = max;
        // 从开始位置和结束位置，向中间位置寻找，直到开始位置=结束位置
        while(i < j){
            // 结束位置大于对比值时,结束位置往前移动
            while(i < j && key < intArray[j]){
                j--;
            }
            // 开始位置小于对比值时,开始位置往后移动
            while(i < j && key > intArray[i]){
                i++;
            }
            // 需判断交换的位置是否相等，如果相等，则继续移动，否则会死循环
            if(i < j && intArray[i] == intArray[j]){
                i++;
            }else{
                // 此时，结束位置值小于key，开始位置值大于key，则交换
                int temp = intArray[i];
                intArray[i] = intArray[j];
                intArray[j] = temp;
            }

        }
        // 对一次排序完的左边子串继续排序
        if(min < i-1) intArray = myQuickSort(intArray,min,i-1);
        // 对一次排序完的右边子串继续排序
        if(max > j+1) intArray = myQuickSort(intArray,j+1,max);
        return intArray;
    }
    public static void main(String[] args) {
        int arr[] = new int[]{3,3,3,7,9,122344,4656,34,34,4656,5,6,7,8,9,343,57765,23,12321};
        int len = arr.length-1;
//        arr=qsort(arr,0,len);
        arr=myQuickSort1(arr,0,len);
        for (int i:arr) {
            System.out.print(i+"\t");
        }
    }
}

2、归并排序：

利用了分而治之思想 fork-join

public class MergeSort {
    public static int[] mergeSort(int[] nums, int l, int h) {
        if (l == h)
            return new int[] { nums[l] };

        int mid = l + (h - l) / 2;
        int[] leftArr = mergeSort(nums, l, mid); //左有序数组
        int[] rightArr = mergeSort(nums, mid + 1, h); //右有序数组
        int[] newNum = new int[leftArr.length + rightArr.length]; //新有序数组

        int m = 0, i = 0, j = 0;
        while (i < leftArr.length && j < rightArr.length) {
            newNum[m++] = leftArr[i] < rightArr[j] ? leftArr[i++] : rightArr[j++];
        }
        while (i < leftArr.length)
            newNum[m++] = leftArr[i++];
        while (j < rightArr.length)
            newNum[m++] = rightArr[j++];
        return newNum;
    }
    /**
        自己手敲代码
        @param iArray 需要排序的数组
        @param min 排序下标
        @param max 排序上标
     */
    public static int[] myMergeSort(int[] iArray,int min,int max){
        if(min == max){
            return new int[]{iArray[min]};
        }
        int mid = (min+max)/2;
        // 需要两个临时数组，存放原数组分为两个的有序数组
        int[] minArray = myMergeSort(iArray,min,mid);
        int[] maxArray = myMergeSort(iArray,mid+1,max);
        // 一个临时数组存放排好序的数组
        int[] tempArray = new int[minArray.length + maxArray.length];
        // 三个变量，m,n记录每次比较的位置，p记录临时数组存放的下标
        int m = 0,n = 0,p = 0;
        while( m < minArray.length && n < maxArray.length){
            // 依次从两个数组拿出最小值，与另一个数组的最小值比较，取出其中最小的放入临时数组
            // 并且此数组中的最小值下标加一，取出当前最小
            tempArray[p++] = minArray[m] > maxArray[n] ? maxArray[n++]:minArray[m++];
        }
        // 如果两个数组有没循环完的，说明这些都是比已经存入临时数组的值大的，直接追加到临时数组最后
        while( m < minArray.length){
            tempArray[p++] = minArray[m++];
        }
        while( n < maxArray.length){
            tempArray[p++] = maxArray[n++];
        }
        return tempArray;
    }

    public static void main(String[] args) {
        int[] nums = new int[] { 9, 8, 7, 6, 5, 4, 3, 2, 10 };
        int[] newNums = myMergeSort(nums, 0, nums.length - 1);
        for (int x : newNums) {
            System.out.print(x);
        }
    }
}

3、冒泡排序：

两个for循环，从最高位开始，把最大值放到数组末尾

public class BubbleSort {

    public static int[] myBubbleSort(int[] array){
        // 标志，如果此标志为false，则表示当前循环没有移动元素，表示已经排好序了
        boolean flag = false;
        for(int i = 0;i < array.length-1;i++){
            for(int j = array.length-1;j > i;j--){
                // 每次循环，需要设置标志位为false
                flag = false;
                if(array[j] < array[j-1]){
                    int temp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = temp;
                    flag = true;
                }
            }
            if(!flag) break;
        }
        return array;
    }

    public static void main(String[] args) {
        int arr[] = new int[]{3,3,3,7,9,122344,4656,34,34,4656,5,6,7,8,9,343,57765,23,12321};
        int len = arr.length-1;
//        arr=qsort(arr,0,len);
        arr=myBubbleSort(arr);
        for (int i:arr) {
            System.out.print(i+"\t");
        }
    }
}