快速排序、双路快排、插入排序、冒泡排序、选择排序、堆排序、归并排序、基数排序

一、快速排序

快速排序(以pivot为中枢比他大的在他右边，比他小的在他左边)

二、双路快排

import java.util.Random;
//双路快排 用random可以让数据更分散
class Solution {

    private final static Random random = new Random(System.currentTimeMillis());
    
    public int[] sortArray(int[] nums) {
        quickSort(nums, 0, nums.length - 1);
        return nums;
    }

    private void quickSort(int[] nums, int left, int right) {
        if (left >= right) {
            return;
        }

        int pivotIndex = partition(nums, left, right);
        quickSort(nums, left, pivotIndex - 1);
        quickSort(nums, pivotIndex + 1, right);
    }

    private int partition(int[] nums, int left, int right) {
        // [left..right]
        int randomIndex = left + random.nextInt(right - left + 1); 
        swap(nums, left, randomIndex);
        
        int pivot = nums[left];

        int le = left + 1; // le: less equals
        int ge = right; // ge: greater equals
        // all in nums[left + 1..le) <= pivot
        // all in nums(ge..right] >= pivot
        while (true) {
            while (le <= ge && nums[le] < pivot) {
                le++;
            }

            while (le <= ge && nums[ge] > pivot) {
                ge--;
            }

            // le 来到了第一个大于等于 pivot 的位置
            // ge 来到了第一个小于等于 pivot 的位置

            if (le >= ge) {
                break;
            }
            swap(nums, le, ge);
            le++;
            ge--;
        }
        
        swap(nums, left, ge);
        return ge;
    }

    private void swap(int[] nums, int index1, int index2) {
        int temp = nums[index1];
        nums[index1] = nums[index2];
        nums[index2] = temp;
    }

}

三、SheelSort

三、插入排序

四、冒泡排序

小小的优化

五、选择排序

public void selectSort(int[] nums){
    int temp;
    int global;
    for (int i=0;i<nums.length-1;i++){
        global=i;
        for (int j=i+1;j< nums.length;j++){
            if(nums[j]<nums[global]){
                global=j;
            }
        }
        temp=nums[i];
        nums[i]= nums[global];
        nums[global]=temp;
    }
}

六、堆排序

public void heapify(int[] tree,int cur,int n){
    if(cur >= n){
        return;
    }
    int max=cur;
    int left=cur*2+1;
    int right=cur*2+2;
    if(left<n&&tree[left]>tree[max]){
        max=left;
    }
    if (right<n&&tree[right]>tree[max]){
        max=right;
    }
    if(max!=cur){
        swap(tree,max,cur);
            heapify(tree,max,n);
    }
}

public void buildHeap(int[] tree,int n){
    int lastNode=n-1;
    int parent=(lastNode-1)/2;
    for (int i=parent;i>=0;i--){
        heapify(tree,i,n);
    }
}

public void sortArray(int[] nums){
    int n=nums.length;
    buildHeap(nums,n);
    for(int i=n-1;i>=0;i--){
        swap(nums,i,0);
        heapify(nums,0,i);
    }
    System.out.println("你好啊");
}


public void swap(int[] tree,int left,int right){
    int temp=tree[left];
    tree[left]=tree[right];
    tree[right]=temp;
}

七、归并排序

八、基数排序

int[] temp=new int[100];
int[] bucket=new int[10];

int maxBit(int[] data,int n){
    int maxData=data[0];
    for(int i=1;i<n;i++){
        if(maxData<data[i])
             maxData=data[i];
    }

    int d=1;
    while(maxData>=10){
        maxData/=10;
        d++;
    }
    return d;
}

void radixsort(int[] data){
    int n=data.length;
    int d=maxBit(data,n);
    int i,j,k;
    int mod=1;
    for( i=1;i<=d;i++){
        for(j=0;j<10;j++){
            bucket[j]=0;
        }
        for(j=0;j<n;j++){
            k=(data[j]/mod)%10;
            bucket[k]++;
        }
        for(j=1;j<10;j++){
            bucket[j]=bucket[j-1]+bucket[j];
        }
        for(j=n-1;j>=0;j--){
            k=(data[j]/mod)%10;
            temp[bucket[k]-1]=data[j];
            bucket[k]--;
        }
        for(j=0;j<n;j++){
            data[j]=temp[j];
        }
        mod*=10;
    }
}