C++：内部排序

 

内部排序算法比较

1. 堆排序和归并排序时间一般。堆排序不稳定归并排序空间一般。
2. 插入排序和冒泡排序有最好时间且稳定，但时间差。
3. 快速排序空间差且不稳定。
4. 直接选择排序时间差不稳定。
5. 元素基本有序时，插入排序效率最高。 

---

实现插入、冒泡、快速、选择、堆、归并6种排序。为了简洁，把写成，所以下面的代码只适合整数排序。

project/sub.h

#ifndef _SUB_H_
#define _SUB_H_

class Sort{
  public:
    Sort();
    void InsertSort(int *a, int n);
    void BubbleSort(int *a, int n);
    void QuickSort(int *a, int n);
    void SelectSort(int *a, int n);
    void HeapSort(int *a, int n);
    void MergeSort(int a[], int n);
  private:
    void QSort(int *a, int low, int high);
    int partition(int *a, int low, int high);
    void HeapAdjust(int *a, int s, int m);
    void MSort(int SR[], int TR1[], int s, int t);
    void Merge(int SR[], int TR[], int i, int m, int n);
};

#endif

project/sub.cc

#include <sub.h>
#include <algorithm>
using namespace std;

Sort::Sort(){
}

void Sort::InsertSort(int *a, int n){
    int temp,j;
    for(int i=1;i<n;i++){
        if(a[i]<a[i-1]){
            temp=a[i];
            for(j=i-1; j>-1 && a[j]>temp; j--)
                a[j+1]=a[j];
            a[j+1]=temp;
        }
    }
}

void Sort::BubbleSort(int *a, int n){
    for(int i=n-1; i>1; i--){
        int flag=0;
        for(int j=0; j<i; j++)
            if(a[j]>a[j+1]){
                flag=1;
                swap(a[j],a[j+1]);
            }
        if(flag==0)
            break;
    }
}

void Sort::QuickSort(int *a, int n){
    QSort(a, 0, n-1);
}

void Sort::QSort(int *a, int low, int high){
    if(low<high){
        int pivotloc=partition(a, low, high);
        QSort(a, low, pivotloc-1);
        QSort(a, pivotloc+1, high);
    }
}

int Sort::partition(int *a, int low, int high){
    int pivotkey=a[low];
    while(low<high){
        while (low<high && a[high]>pivotkey-1) high--;
        a[low]=a[high];
        while (low<high && a[low]<pivotkey+1) low++;
        a[high]=a[low];
    }
    a[low]=pivotkey;
    return low;
}

void Sort::SelectSort(int *a, int n){
    for(int i=0; i<n; i++){
        int min=i;
        for(int j=i+1; j<n; j++)
            if(a[j]<a[min])
                min=j;
        if(min!=i)
            swap(a[i], a[min]);
    }
}

//从下标1开始排序
void Sort::HeapSort(int *a, int n){
    for(int i=n/2; i>0; i--)
        HeapAdjust(a, i, n);
    for(int i=n; i>1; i--){
        swap(a[1], a[i]);
        HeapAdjust(a, 1, i-1);
    }
}

void Sort::HeapAdjust(int *a, int s, int m){
    int rc=a[s];
    for(int j=2*s; j<m+1; j*=2){
        if(j<m && a[j]<a[j+1])
            j++;
        if(rc>a[j]-1)
            break;
        a[s]=a[j];
        s=j;
    }
    a[s]=rc;
}

void Sort::MergeSort(int a[], int n){
    MSort(a, a, 0, n-1);
}

void Sort::MSort(int SR[], int TR1[], int s, int t){
    int TR2[11];
    if(s==t) TR1[s]=SR[s];
    else{
        int m=(s+t)/2;
        MSort(SR, TR2, s, m);
        MSort(SR, TR2, m+1, t);
        Merge(TR2, TR1, s, m, t);
    }
}

void Sort::Merge(int SR[], int TR[], int i, int m, int n){
    int j,k;
    for(j=m+1, k=i; i<m+1 && j<n+1; k++){
        if(SR[i]<SR[j]) TR[k]=SR[i++];
        else TR[k]=SR[j++];
    }
    if(i<m+1)
        for(int v=0; v+i<m+1; v++) TR[k+v]=SR[i+v];
    if(j<n+1)
        for(int v=0; v+j<n+1; v++) TR[k+v]=SR[j+v];
}

project/main.cc

#include <iostream>
#include <sub.h>
using namespace std;

int main(){
    Sort sort;
    int x[10]={8,0,2,6,4,9,7,1,5,3};
    sort.QuickSort(x,10);
    for(int i=0;i<10;i++)
        cout<<x[i]<<" ";
    cout<<endl;
}