【排序算法】升序排序数组

冒泡排序

把最大的往最后冒

class Solution {
    public int[] sortArray(int[] nums) {
        int tmp;
        boolean flag=false;
        for (int i=0;i<nums.length-1;i++){
            flag=false;
            for (int j=1;j<nums.length-i;j++){
                if (nums[j]<nums[j-1]){
                    flag=true;
                    // 交换
                    tmp=nums[j-1];
                    nums[j-1]=nums[j];
                    nums[j]=tmp;
                } 
            }
            if (!flag) break;
        }
        return nums;
    }
}

选择排序

每次找到最小的，与待排序列的第一个元素交换

class Solution {
    public int[] sortArray(int[] nums) {
        int min_index;
        int tmp;
        for (int i=0;i<nums.length-1;i++){
            min_index=i;
            for (int j=i+1;j<nums.length;j++){
                if (nums[j]<nums[min_index]) min_index=j;
            }
            // 与待排序列里第一个元素交换
            tmp=nums[i];
            nums[i]=nums[min_index];
            nums[min_index]=tmp;
        }
        return nums;
    }
}

插入排序

类似打扑克，每次来一个牌，该牌从右往左 与手里的牌（手里的牌已经有序）进行比较，选择一个位置插入。
遍历数组，取出j位置的元素x，与[0,j-1]位置的元素进行比较，当nums[t]>x时，nums[t+1]=nums[t]; 当nums[t]<=x时，nums[t+1]=x。

class Solution {
    public int[] sortArray(int[] nums) {
        // 21345
        int x,j;
        for (int i=0;i<nums.length;i++){
            x=nums[i];
            for (j=i-1;j>=0;j--){
                if (x<nums[j]) nums[j+1]=nums[j];
                else break;
            }
            nums[j+1]=x;
        } 
        return nums;
    }
}

归并排序

分治

class Solution {
    int[] tmp;
    public int[] sortArray(int[] nums) {
        tmp=new int[nums.length];
        // 12435
        mergeSort(nums,0,nums.length);
        return nums;
    }

    public void mergeSort(int[] nums,int start,int end){
        if (start+1==end) return;
        int average=(end-start)/2;
        mergeSort(nums,start,start+average);
        mergeSort(nums,start+average,end);
        // 合并
        int i=start;
        int j=start+average;
        int t=0;
        while (i<start+average && j<end){
            tmp[t++] = nums[i]<=nums[j]?nums[i++]:nums[j++];
        }
        while (i<start+average){
            tmp[t++]=nums[i++];
        }
        while (j<end){
            tmp[t++]=nums[j++];
        }
        i=start;
        for (t=0;t<end-start;t++){
            nums[i++]=tmp[t];
        }
    }
}

快速排序

每轮选一个基准元素，然后最终使得基准元素左边都是小于基准的，右边是大于基准的

【思路1】
双指针l,r分别指向待排序列第一个元素、最后一个元素；
基准元素为l初始指向的元素；（l空，可被赋值，找右边小于base的）
首先比较r指向元素和基准元素，如果nums[r]<=base，nums[l]=nums[r]，l指针右移（r空，可被赋值，找左边大于base的）；【否则r左移】
比较nums[l]和base，如果nums[l]>base，nums[r]=nums[l]，r指针左移（l空，可被赋值，找右边小于base的）；【否则l指针右移】
直到 l==r, 基准元素放置于此，基准左边元素都小于基准，右边都大于基准；接着分别对左边序列快排，右边序列快排；

class Solution {
    public int[] sortArray(int[] nums) {
        quickSort(nums,0,nums.length-1);
        return nums;
    }

    public void quickSort(int[] nums,int begin,int end){
        if (begin<end){
            int mid=partition(nums,begin,end);
            quickSort(nums,begin,mid-1);
            quickSort(nums,mid+1,end);
        }
    }

    public int partition(int[] nums,int l,int r){
        int base=nums[l];
        while (l<r){
            while (l<r && nums[r]>base){
                r--;
            }
            if (l<r){
                nums[l]=nums[r];
                l++;
            }
            while (l<r && nums[l]<=base){
                l++;
            }
            if (l<r){
                nums[r]=nums[l];
                r--;
            }
        }
        nums[l]=base;
        return l;
    }
}

【思路2】
选取最后一个元素为基准元素，low指向第一个元素，high从序列第一个元素遍历到倒数第二个元素，如果high指向的元素小于base（且low!=high），交换nums[low]和nums[high]，low++；
最后交换nums[low]和最后一个元素；

class Solution {
    public int[] sortArray(int[] nums) {
        quickSort(nums,0,nums.length-1);
        return nums;
    }

    public void quickSort(int[] nums,int begin,int end){
        if (begin<end){
            int mid=partition(nums,begin,end);
            quickSort(nums,begin,mid-1);
            quickSort(nums,mid+1,end);
        }
    }

    public int partition(int[] nums,int l,int r){
        int base=nums[r];
        int low=l;
        int tmp;
        for (int high=l;high<=r-1;high++){
            if (nums[high]<=base){
                if (low!=high){
                    tmp=nums[high];
                    nums[high]=nums[low];
                    nums[low]=tmp;
                }
                low++;
            }
        }
        tmp=nums[r];
        nums[r]=nums[low];
        nums[low]=tmp;
        return low;
    }
}

堆排序

桶排序

计数排序