各种排序

冒泡排序

时间复杂度O(N^2）空间复杂度O(1)
给定一个具有len长度的数组num，对数组中相邻的元素j和j+1比较大小，num[j] > num[j+1],则交换两者。每一趟排序之后都能保障最后比较的是数值最大的，第i趟排序过程中len - i -1的元素不参与相邻元素比较（因为此时他已经是比较过后的最大值）

public void bubblingSort(int[] num) {
        int len = num.length;
        for (int i = 0; i < len; i++) {
            for(int j = 0; j < len - i - 1; j++) {
                if (num[j] > num[j+1]) {
                    int c = num[j];
                    num[j] = num[j+1];
                    num[j+1] = c;
                }
            }
        }
    }

选择排序

时间复杂度O(N^2) 空间复杂度O(1)
当前位置假定为最小值，遍历后面出现的元素，如果有更小的值，则两者交换元素。

    //选择排序
    public void chooseSort(int[] num) {
        int len = num.length;
        for(int i = 0 ; i < len-1 ;i++) {
            int min = num[i];
            int flag = i; //记录最小位置下标
            for (int j = i+1; j < len; j++) {
                if (num[j] < min) {
                    min = num[j];
                    flag = j;
                }
            }
            if (i != flag) {
                int c = num[i];
                num[i] = min;
                num[flag] = c;
                
            }
        }
    }

插入排序

时间复杂度O(N^2) 空间复杂度O(1)
假定第一个元素是有序的，后面的是无序的，从第二个元素开始，依次对每个元素插入到前面有序的数组中。

public void insertSort(int[] num) {
        for (int i = 1; i < num.length; i++) {
            for (int j = i;j >0; j--) {
               if (num[j] < num[j - 1]) {
                int c = num[j-1];
                num[j-1] = num[j];
                num[j] = c;
            }
            }
        }
    }

快速排序

时间复杂度O(NlogN) 空间复杂度O(1)
从给定数组中num，先找出一个基准数X,确定左右边界L和右边界R.
另循环变量 i = L, j= R
1)先从后面的右边界开始扫描，找到一个比X小的值，然后将左右边界的值交换，i++;
2)从左边界再扫描，找到一个大于等于X的值，然后左右边界值交换，j–;
3)重复12步骤，直到 i==j
将中间的num[i] = X
执行完123步骤之后，再对num[L,i-1]和num[i+1,R]的数组分别快速排序，再次执行123步骤

//快速排序
    public static void quickSort(int[] num, int i, int j) {
        int l = i;
        int r = j;
        int x = num[l];
        if (l < r) {
            while(i < j) {
                //先从后往前扫描，小于标定值的放在前面
                while (i < j  && num[j] >= x) {
                    j--;
                }
                if (i < j) {
                    num[i++] = num[j];
                }
                //从前往后扫描，大于等于标定值的放在后面
                while (i < j && num[i] < x) {
                    i++;
                }
                if (i < j) {
                    num[j--] = num[i];
                }
            }
            num[i] = x;
            quickSort(num, l, i-1);
            quickSort(num, i+1,r );
        }
       
    }

计数排序

它的优势在于在对一定范围内的整数排序时，它的复杂度为Ο(n+k)（其中k是整数的范围），快于任何比较排序算法

//    计数排序
    public static void coutSort(int[] num) {
        //首先找出数组中的最大元素和最小元素，此处假设取值范围在0-k之间
        int max = num[0];     
        for (int i = 0; i < num.length; i++) {
            if (num[i] > max) {
                max = num[i];
            }
        }
        //创建新的计数数组，数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1）
        int len = max + 1;
        int[] c = new int[len];
        //将原数组中的每个元素计算出现的次数
        for (int i = 0; i < num.length; i++) {
            c[num[i]] ++;
        }
        int index = 0;
        //将原来数组重新赋值,每放一个元素就将C(i)减去1
        for (int i = 0; i < c.length; i++) {
            while (c[i] > 0) {
                num[index++] = i;
                c[i]--;
            }
        }
    }