常见几个排序总结（java版本）

常见排序方法汇总

1.冒泡排序，时间复杂度O(n^2),空间复杂度O(1)

public static void bubble(int []arr){
        if(arr == null || arr.length < 2){
            return ;
        }
        for (int end = arr.length; end > 0; end--) {
            for (int i = 0; i < end -1; i++) {
                if(arr[i] > arr[i+1]){
                    swap(arr,i,i+1);
                }
            }
        }    
}

public static void swap(int arr[] ,int i,int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
}

2.选择排序，时间复杂度O(n^2),空间复杂度O(1)

public static void selectSort(int arr[]){
        if(arr.length < 2 || arr == null){
            return;
        }

        for (int i = 0; i < arr.length-1; i++) {
            int index = i;
            for (int j = i+1; j < arr.length; j++) {
                if(arr[i] > arr[j]){
                    index = j;
                }
            }
            swap(arr, index, i);
        }
}

3.插入排序，时间复杂度O(n^2),空间复杂度O(1)

public static void insertSort(int[] arr){
        if(arr == null || arr.length < 2){
            return ;
        }

        for(int i = 0;i < arr.length - 1;i++){
            for(int j = i+1;j > 0 && arr[j] > arr[j-1];j--){
                swap(arr,j,j-1);
            }
        }
}

4.归并排序，时间复杂度O(nlogn),空间复杂度O(n)

public static void mergeSort(int []arr){
        if(arr == null || arr.length < 2){
            return ;
        }
        sort(arr, 0, arr.length-1);
}

public static void sort(int[] arr,int L, int R){
    if(L == R){
        return ;
    }
    int mid = L+( R-L)/2;
    sort(arr, L, mid);//T(n/2)  先左边排序
    sort(arr, mid+1, R);//T(n/2) 再右边排序
    merge(arr, L, mid, R);//O(N) 最后整体排序
}

public static void merge(int []arr,int L, int mid,int R){//外排法
    int help[] = new int[R - L +1];
    int i = 0;
    int p1 = L;
    int p2 = mid + 1;
    while(p1 <= mid && p2 <= R ){
        help[i++] = arr[p1] < arr[p2] ? arr[p1++] :arr[p2++];
    }
    //有一个越界了
    while(p1 <= mid){
        help[i++] = arr[p1++];
    }
    while(p2 <= R){
        help[i++] = arr[p2++];
    }
    for (int j = 0; j < help.length; j++) {
        arr[L+j] = help[j];
    }

}

5.快速排序，时间复杂度O(nlogn),空间复杂度O(n)

public static void quickSort(int arr[] ,int L,int R){
        if(L < R){
            int x = sortNum(arr, arr[R]);
            quickSort(arr, L, x-1);
            quickSort(arr, x+1, R);
        }
}
public static int sortNum(int []arr,int num){

        int x = -1;//表示比num小的下标记设置成-1
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] <= num){
                swap(arr, i, ++x);//比num小就与交换位置
            }
        }
        return x;
}

/**
*基于荷兰国旗问题的改进
*/
public static void quickSort1(int arr[] ,int L,int R){
    //荷兰国旗问题可以吧等于num的都放在中间，如果说数组中每个数都不相同，那此方法等同于快排
        if(L < R){
            int [] p = partition(arr, L, R,arr[R]);
            quickSort(arr, L, p[0]-1);
            quickSort(arr, p[1]+1, R);
        }
}
/**
*随机快排序
*/
//改进快排(随机快拍)因为总拿最后一个数做为num分界，若数组有序如1,2,3,4,5（或者5,4,3,2,1）
//这样就会每次以num分的时候如果只有小于num和等于num,或者只有大于num和等于num的时候，时间复杂度就变成了O(n^2);
//但是随机快排就能避免这样情况，按照期望可算出 ，时间复杂度O(NlogN);
//随机快排 额外空间复杂度O(logN)（概率上的期望）实际上logN是每次划分的那个Num的断点位置p[]，每次分两个部分，所以LogN(实际上也是概率期望)，
//但是传统快排数组如果有序的时候就每个位置都有断点，额外空间复杂度就成了o（N），所以随机快排实际上也改进了这一点
public static void quickSort2(int arr[] ,int L,int R){
        if(L < R){
            swap(arr,L +(int) (Math.random()*(R - L + 1)),R);
            int [] p = partition(arr, L, R, arr[R]);
            quickSort2(arr, L, p[0]-1);
            quickSort2(arr, p[1]+1, R);
        }
}

public static int[] partition(int arr[],int L,int R,int num){
        int less = L - 1;
        int more = R + 1;
        int cur = L;

        while(cur < more){
            if(arr[cur] < num){
                swap(arr,++less, cur++);
            }else if(arr[cur] > num){
                swap(arr, cur, --more);
            }else{
                cur++;
            }
        }
        return new int[]{less + 1,more - 1};//返回的数组代表与num相等（或者大小分界处）的数的起始下标和终止下边
}

6.堆排序，时间复杂度O(nlogn),空间复杂度O(1)

public static void heapSort(int []arr){
        if(arr == null || arr.length < 2){
            return;
        }

        for (int i = 0; i < arr.length; i++) {
            heapInsert(arr,i);//将数组转换为大根堆，此过程的复杂度O(N),因为每个节点插入的时候(heapInsert过程)调整空间在logN则所有节点就是（log1+。。。logN-1）,收敛于O(N)
        }

        int heapSize = arr.length;
        swap(arr,0,--heapSize);

        while (heapSize > 0) {
            heapify(arr, 0, heapSize);
            swap(arr, 0, --heapSize);
        }

  }

    private static void heapInsert(int[] arr, int index) {

        while(arr[index] > arr[(index-1)/2]){
            swap(arr, index,(index-1)/2);
            index = (index-1)/2;
        }
    }

    //heapSize就是大根堆的元素个数
    private static void heapify(int arr[],int index,int heapSize){
        int left = index * 2 + 1;
        while(left < heapSize){//没越界
            int largest = left + 1 <heapSize && arr[left +1] > arr[left]
                    ? left + 1 :left;//若右孩子也存在，就取左右孩子中大的数字的下标，没有就是左孩子的
            largest = arr[largest] > arr[index] ? largest : index;//孩子和自己比较，较大的值下标

            if(largest == index){
                break;//最大的数字就是自己的话，说明不需要调整
            }

            swap(arr, largest, index);//说明需要调整
            index = largest;
            left = index * 2 + 1;
        }
    }