算法拾遗系列-常用排序算法合集

　　　　前几天要参加去哪儿的实习生笔试，所有又把集中常用也会常考的排序算法又拿出来温习了一遍。发现很长时间练习，还是会很生疏。这些算法说起来好像都能讲出基本的步骤，但真的写起来发现会出现很多纰漏。边界条件什么的常常考虑不周全，要能真正写出bug-free的程序还需要不断训练，正应了那句老话-“talk is cheap,show me the code!”，IT行业，code才是硬通货。

　　　　转入正题，常用的几种排序算法中，需要不停对比相邻元素的算法基本上时间复杂度都是O(n2),而用到了分治方法的基本都是O(nlogn)。

　　　　下面是代码，编译通过，结果也都正确。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

template<typename T>
void printArray(T *arr,int n){
    for (int i=0;i<n;i++)
        cout<<arr[i]<<" ";
    cout<<endl;
}

//二分搜索
//T(n)=O(nlogn)
int binarySearch(int *arr,int beg,int end,int key){
    if (end >= beg){
        int mid = (beg+end)/2;
        if (arr[mid] == key)
            return mid;
        if (arr[mid] <key )
            return binarySearch(arr,mid+1,end,key);
        else
            return binarySearch(arr,beg,mid-1,key);
    }
    return -1;
}

template<typename T>
void swap(T *a,T *b){
    T tmp = *a;
    *a = *b;
    *b = tmp;
}

//选择排序
/*
    每次迭代都将剩下未排序序列中最小元素
    放在未排序序列开始处
    T(n)=O(n2)
*/
void SelectionSort(int *arr,int n){
    int i,j,min;
    for (i=0;i<n-1;i++){
        min = i;
        for (j = i+1;j<n;j++){
            if (arr[j]<arr[min])
                min = j;
        }
        swap(&arr[min],&arr[i]);
    }
}

//冒泡排序
/*
    算法每趟都交换相邻元素（如果它们无序）,使最大元素位于最右侧
    并在下次扫描中排出该元素
    T(n)=O(n2)
*/
void BubbleSort(int *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]);
    }
}

//插入排序
/*
    算法就像打牌每次抽出一张牌，在左边找好位置并插入
    T(n)=O(n2)
*/
void InsertionSort(int *arr,int n){
    int i,j;
    for (i=1;i<n;i++){
        int tmp = arr[i];
        for (j=i-1;j>=0 && arr[j]>tmp;j--)
            arr[j+1] = arr[j];
        arr[j+1] = tmp;
    }
}

//合并 排序
/*
    算法将数组分为两半，递归调用合并排序，
    最后将两半排好序的数组再次合并
    T(n)=O(nlogn)
*/
void merge(int *arr,int beg,int mid,int end){
    int n1 = mid - beg+1;
    int n2 = end - mid;

    int *a1 = new int[n1];
    int *a2 = new int[n2];

    for (int i=0;i<n1;i++)
        a1[i] = arr[beg+i];
    for (int i=0;i<n2;i++)
        a2[i] = arr[mid+1+i];

    int i=0,j=0,k=beg;
    while (i<n1 && j<n2){
        if (a1[i] <= a2[j]){
            arr[k] = a1[i];
            ++i;
        }
        else{
            arr[k] = a2[j];
            ++j;
        }
        ++k;
    }

    while(i < n1){
        arr[k] = a1[i];
        ++i;
        ++k;
    }

    while(j < n2){
        arr[k] = a2[j];
        ++j;
        ++k;
    }
}

void MergeSort(int *arr,int beg,int end){
    if (beg < end){
        int mid = (beg+end)/2;
        MergeSort(arr,beg,mid);
        MergeSort(arr,mid+1,end);
        merge(arr,beg,mid,end);
    }
}

//堆排序
/*
    建一个最小堆，则数组就是有序的
    本算法建的是最大堆，因此最后还要对数组做堆有序处理
    T(n)=O(nlogn)
*/
typedef struct Heap{
    int size;
    int *arr;
}Heap;

//维护最大堆有序
/*
    我们一开始就假定根节点为LEFT(i)和RIGHT(i)的二叉堆都是最大堆。
    当maxheap[i]的值比其子节点的值小时，
    maxHeapify通过让maxheap[i]的值在最大堆中逐级下降，
    使得以i为根的子树保持最大堆有序性
*/
void maxHeapify(Heap* maxheap,int idx){
    int left = (idx<<1)+1;
    int right = (idx+1)<<1;
    int largest = idx;
    if (left < maxheap->size && maxheap->arr[left] > maxheap->arr[largest])
        largest = left;
    if (right < maxheap->size && maxheap->arr[right] > maxheap->arr[largest])
        largest = right;
    if (largest != idx){
        swap(&maxheap->arr[largest],&maxheap->arr[idx]);
        maxHeapify(maxheap,largest);//percolate down
    }
}

Heap* createMaxHeap(int *arr,int n){
    int i;
    Heap* maxheap = (Heap*)malloc(sizeof(struct Heap));
    maxheap->size = n;
    maxheap->arr = arr;

    //堆有序操作
    for (int i=(maxheap->size-2)/2;i>=0;--i)
        maxHeapify(maxheap,i);
    return maxheap;
}

void HeapSort(int *arr,int n){
    Heap* maxheap = createMaxHeap(arr,n);
    while (maxheap->size >1){
        swap(&maxheap->arr[0],&maxheap->arr[maxheap->size-1]);
        --maxheap->size;
        //从根节点再次对整个堆进行堆有序操作
        maxHeapify(maxheap,0);
    }
}


//快排
/*
    选取一个哨兵元素pivot，使数组中所有小于pivot的元素位于pivot左边
    所有大于pivot的元素位于pivot右边
    T(n)=O(nlogn)
    worst situation consume O(n2)
*/
int Partition(int *arr,int beg,int end){
    //选择最后一个元素的中值为pivot
    int pivot = arr[end];
    int i= beg;
    int j= end-1;
    while (i < j){
        if (arr[i] <= pivot){
            ++i;
            continue;
        }
        if (arr[j] >= pivot){
            --j;
            continue;
        }
        swap(&arr[i],&arr[j]);
        ++i;
        --j;
    }
    swap(&arr[j],&arr[end]);
    return j;
}

void QuickSort(int *arr,int beg,int end){
    if (beg < end){
        int p = Partition(arr,beg,end);
        QuickSort(arr,beg,p-1);
        QuickSort(arr,p+1,end);
    }
}

//桶排
/*
    假设输入序列服从均匀分布平均情况下T(n)=O(n)
    将【0,1）区间划分为n个大小相同子区间(bucket)，将n个输入数分别放到对应桶中，
    然后先对各个桶中数据进行排序，再遍历各个桶，按次序列出各个桶中元素即可
*/
void BucketSort(float *arr,int n){
    //buckets
    vector<vector<float> > buckets(n);
    for (int i=0;i<n;i++){
        int bi = arr[i]*n;//
        buckets[bi].push_back(arr[i]);
    }
    for (int i=0;i<n;i++)
        sort(buckets[i].begin(),buckets[i].end());
    int idx = 0;
    for (int i=0;i<n;i++)
        for (int j=0;j<buckets[i].size();j++)
            arr[idx++] = buckets[i][j];

}

//希尔排序
/*
    希尔排序是插入排序的变种
    有间隔的进行插入排序
*/
void ShellSort(int *arr,int n){
    for (int gap=n/2;gap>0;gap /= 2){
        for (int i=gap;i<n;i += 1){
            int tmp = arr[i];
            int j;
            for (j=i;j>=gap && arr[j-gap] > tmp;j -= gap)
                arr[j] = arr[j-gap];
            arr[j] = tmp;
        }
    }
}

int main()
{
    int arr1[10] = {10,5,2,9,3,7,8,6,-1,4};
    cout<<"Selection sort:";
    SelectionSort(arr1,10);
    printArray(arr1,10);
    int idx = binarySearch(arr1,0,9,4);
    if (idx == -1)
        cout<<"Couldn't find..."<<endl;
    else 
        cout<<"Find 4 in index: "<<idx<<endl;

    cout<<"Bubble sort:";
    int arr2[10] = {10,5,2,9,3,7,8,6,-1,4};
    BubbleSort(arr2,10);
    printArray(arr2,10);

    cout<<"InsertitionSort: ";
    int arr3[10] = {10,5,2,9,3,7,8,6,-1,4};
    InsertionSort(arr3,10);
    printArray(arr3,10);

    cout<<"MergeSort: ";
    int arr4[10] = {10,5,2,9,3,7,8,6,-1,4};
    MergeSort(arr4,0,9);
    printArray(arr4,10);

    cout<<"HeapSort: ";
    int arr5[] = {10,5,2,9,3,7,8,6,-1,4};
    int n5 = sizeof(arr5)/sizeof(arr5[0]);
    HeapSort(arr5,n5);
    printArray(arr5,n5);

    cout<<"QuickSort: ";
    int arr6[10] = {10,5,2,9,3,7,8,6,-1,4};
    QuickSort(arr6,0,9);
    printArray(arr6,10);

    cout<<"BucketSort: ";
    float arr7[10] = {0.12,0.29,0.89,0.31,0.10,0.49,0.99,0.60,0.08,0.7};
    BucketSort(arr7,10);
    printArray(arr7,10);

    cout<<"ShellSort: ";
    int arr8[10] = {10,5,2,9,3,7,8,6,-1,4};
    ShellSort(arr8,10);
    printArray(arr8,10);
    return 0;
}

　　　　注释基本上都能解释算法的基本思路，不懂得可以看以下算法导论。

　　　　运行结果如下：

代码参考：www.geeksforgeeks.org

参考书籍：算法导论