五种简单排序算法的比较

冒泡法：这是最原始，也是众所周知的最慢的算法了。时间复杂度为O(n*n)。当数据为正序，将不会有交换，空间复杂度为O(1)。优点：代码简单，算法稳定。缺点：时间复杂度高。

template<typename T>

void bubbleSort(T arr[], int n){

 

       for (int i = 0; i < n; i++){

 

              for (int j = 0; j < n - i - 1; j++){

                     if (arr[j]>arr[j + 1])

                            swap(arr[j], arr[j + 1]);

              }

       }

}

 

直接插入排序：时间复杂度O(n*n) ，空间复杂度O(1)。优点：代码简单，算法稳定。缺点：时间复杂度高。

template<typename T>

void insertionSort(T arr[], int n){

 

       for (int i = 1; i < n; i++){

 

              for (int j = i; j>0 ; j--){

                     if (arr[j] < arr[j - 1])

                            swap(arr[j], arr[j - 1]);

                     else

                            break;

              }

       }

}

 

选择排序：时间复杂度恒为O(n*n)，比较次数n*n次 。空间复杂度O(1)。优点：代码简单，算法稳定。缺点：时间复杂度高。

template<typename T>

void selectionSort(T arr[] , int n ){

 

       for (int i = 0; i < n - 1; i++){

 

              int minIndex = i;

              for(int j = i + 1; j < n; j++)

                     if(arr[j]<arr[minIndex])

                            minIndex = j;

 

              swap(arr[i], arr[minIndex]);

       }

}

 

快速排序：平均时间复杂度log2(n)*n，所有内部排序方法中使用广泛。优点：平均时间复杂度为log2(n)*n，辅助空间O(log2(n))；缺点：不稳定，时间复杂度可能达到O(n*n)；

 

//对arr[l...r]部分进行partition 操作

//返回p，使得arr[l...p-1]<arr[p];arr[p+1...r]>arr[p]

template<typename T>

int __partition(T arr[], int l, int r){

 

       T v = arr[l];

 

       //arr[l+1...j]<v;arr[j+1...i]>v

       int j = l;

       for (int i = l + 1; i <= r; i++){

              if (arr[i] < v){

                     swap(arr[j+1], arr[i]);

                     j++;

              }

       }

       swap(arr[l], arr[j]);

 

       return j;

}

 

//对arr[l...r]部分进行快速排序

template<typename T>

void __quickSort(T arr[], int l, int r){

 

       if (l >= r)

              return;

       int p = __partition(arr, l, r);

       __quickSort(arr, l, p - 1);

       __quickSort(arr, p + 1, r);

}

 

template<typename T>

void quickSort(T arr[], int n){

 

       __quickSort(arr, 0, n - 1);

}

 

归并排序：时间复杂度恒为log2(n)*n，空间复杂度为O(n)；优点：稳定，时间复杂度恒为log2(n)*n。缺点：相比其他排序，空间复杂度为O(n)，空间开销较大。

//递归使用归并排序，对arr[l...r]的范围进行排序

template<typename T>

void __mergeSort(T arr[],int l, int r){

 

       if (l >= r)

              return;

       int mid = (l + r) / 2;

       __mergeSort(arr, l, mid);

       __mergeSort(arr, mid + 1, r);

              //if (arr[mid]>arr[mid + 1])

       __merge(arr, l, mid, r);

 

}

 

//将arr[r...mid]和arr[mid+1...r]两部分进行归并

template<typename T>

void __merge(T arr[], int l, int mid, int r){

 

       T *aux = new T[r-l+1];

       for (int i = l; i <= r; i++)

              aux[i - l] = arr[i];

       int i = l, j = mid + 1;

       for (int k = l; k <= r; k++){

              if (i > mid){

                     arr[k] = aux[j - l];

                     j++;

              }

              else if (j > r){

                     arr[k] = aux[i - l];

                            i++;

              }

              else if (aux[i - l] < aux[j - l]){

                     arr[k] = aux[i-l];

                     i++;

              }

              else{

                     arr[k] = aux[j - l];

                     j++;

              }

       }

       delete[] aux;

}

 

template<typename T>

void mergeSort(T arr[], int n){

 

       __mergeSort(arr, 0, n - 1);

}