常见排序算法以及时间复杂度

一、冒泡排序：

public static void bubbleSort(int []arr) {

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

冒泡排序最好的情况是一趟就排完  时间复杂度为O(n);

最坏的情况就是刚好是反序的 需要循环（n-1）趟  每趟需要循环（n-1-i）次 时间复杂度为 （(n-1)*n）/2    也就是O(n^2)

所以冒泡排序的平均时间复杂度为O(n^2)；

二、选择排序：

public void selectSort(int[] a) {
        for(int i=0;i<a.length;i++){
            int k=i;
            for(int j=i+1;j<a.length;j++){
                if(a[j]<a[k]){
                    k=j;
                }
            }
            if(k>i){
                int temp = a[i];
                a[i]=a[k];
                a[k]=temp;
            }
        }
    }

选择排序最好、最差、平均时间复杂度均为：O(n^2)

三、快速排序：

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);
}   

最坏的情况是，每次所选的中间数是当前序列中的最大或最小元素长度为n的数据表的快速排序需要经过n趟划分，使得整个排序算法的时间复杂度为O(n^2)

理想的情况是，每次划分所选择的中间数恰好将当前序列几乎等分，经过logn趟划分,时间复杂度为O(nlogn)

平均情况下：T(n)=2*T(n/2)+n;      第一次划分

      =2*（2*T(n/4)+n/2）+n;     第二次划分  (=2^2*T(n/4)+2*n)

      =2*(2*(2*T(n/8)+n/4)+n/2)+n;     第三次划分(=2*3*T(n/8)+3*n)

      =.....................

      =2^m+m*n;  第m次划分

因为2^m=n,所以等价于 = n+m*n
所以m=logn，所以T(n)=n+n*logn;   

快速排序的平均时间复杂度是O(n*logn)

原文地址：https://www.cnblogs.com/bimingcong/p/12074452.html