排序算法

排序算法应该也是面试中会经常问到的问题。 /汗  现在就只会快速排序和归并排序。前两天看《算法导论》的堆排序，自己没能写出，代码都写出来了，就是通过不了测试，等过两天再写堆排序吧，今天先把快速排序和归并写了。嗯，而且要开始学 STL了，要不然笔试的时候算法都自己写，太耗时间了。

各种排序算法的比较:  

随机化快速排序:  时间复杂度O(nlogn)  递归树的高度logn    不稳定排序

堆排序:     时间复杂度O(nlogn)    不稳定排序  ，可以用来实现优先队列  top K 数据的问题 

归并排序：  时间复杂度O(nlogn)    稳定排序  

基于比较模型的排序算法的时间复杂度的下届 O(nlogn)

线性时间的排序算法O(n)   基数排序和桶排序  ，还没看，抽时间看一下 

快速排序  时间复杂度平均为O(nlogn)  最差为O(n^2) 采用随机快速排序来避免这种情况

int partition(int *arr,int lo,int hi)
{
    //随机化的快速排序，避免O(n^2)
    swap(arr[lo],arr[lo+rand()%(hi-lo+1)]);
    int pivot = arr[lo];
    while(lo<hi)
    {
        while(lo<hi && arr[hi]>=pivot) 
            --hi;
        arr[lo] = arr[hi];
        
        while(lo<hi && arr[lo]<=pivot)
            ++lo;
        arr[hi] = arr[lo];
    }
    arr[lo] = pivot;
    return lo;
}

void QuickSort(int *arr,int lo,int hi)
{
    if (!arr) return ;
    if (hi-lo <2)  return ;
    int mi = partition(arr,lo,hi-1);
    QuickSort(arr,lo,mi);
    QuickSort(arr,mi+1,hi);    
}

int main()
{
    int arr[] = {3,4,6,-1,0};
    int n = sizeof(arr)/sizeof(int);
    QuickSort(arr,0,n);
    for (int i=0;i<n;i++)
    {
        cout<<arr[i]<<endl;
    }
    return 0;
}

归并排序   时间复杂度稳定在O(nlogn)

void MergeSort(int arr[],int lo,int hi)
{
    if (hi-lo<2)  return;
    int mi = (lo+hi)>>1;
    //以中点为界分别排序
    MergeSort(arr,lo,mi);  
    MergeSort(arr,mi,hi);
    Merge(arr,lo,mi,hi);
}

void Merge(int arr[],int lo,int mi,int hi)
{
    int *A = arr + lo; 
    int lb = mi-lo;
    int *B = new int [lb];   //前子向量
    for (int i=0;i<lb;B[i++]=A[i++]); //复制前子向量
    int lc = hi-mi;
    int *C = arr + mi;      //后子向量
    for (int i=0,j=0,k=0;(j<lb) || (k<lc))
    {
        //加B
        if ((j<lb) && (!(k<lc)||B[j]<=C[k]))  A[i++] = B[j++];
        //加C
        if ((k<lc) && (!(j<lb)||B[j]> C[k]))  A[i++] = C[k++];        
    }
    delete []B;
}

先给堆排序留个坑，最大堆，最小堆，优先队列

好吧，今天下午把堆排序写了，上代码

#include <IOSTREAM>
using namespace  std;

//从0开始计算 left=2*i+1  right=2*i+2  parent=(i-1)/2
//最开始考虑到运行效率，写成了(i-1)>>1,i<<1+2,i<<1+1 
//忽略了"+"的优先级比"<<" 和 ">>"要高 ,结果一直出不来
#define PARENT(i)    (i-1)>>1        //(i-1)/2   // (i-1)>>1
#define RIGHT(i)     (i<<1)+2        //(i*2)+2   // i<<1+2
#define LEFT(i)      (i<<1)+1        //(i*2)+1   // i<<1+1

//使结点i 维持最大堆的性质，length 
void maxHeapInfy(int arr[],int i,int heapsize)
{
    int left = LEFT(i);
    int right = RIGHT(i);
    int largest = i;
    if (left<=heapsize && arr[left]>arr[largest])
        largest = left;
    
    if (right<=heapsize && arr[right]>arr[largest])
        largest = right;

    if (i!=largest)
    {
        swap(arr[i],arr[largest]);
        maxHeapInfy(arr,largest,heapsize);
    }    
}

void buildMaxHeap(int arr[],int heapsize)
{
    //数组元素下标为[0...n],
    //则从n/2到n都为叶结点，单个元素符合MaxHeap性质
    int i=0;
    for (i=heapsize>>1;i>=0;i--)
        maxHeapInfy(arr,i,heapsize);    
}

void maxHeapSort(int arr[],int length)
{
    /*构建MaxHeap以后arr[0]的元素始终都是最大值
    将arr[0] 和 arr[n] 交换，接着将heapsize减一
    然后arr[0...n-1]维持最大堆
    */
    buildMaxHeap(arr,--length);
    for (int i=length;i>0;i--)
    {
        swap(arr[0],arr[i]);
        length--;
        maxHeapInfy(arr,0,length);
    }
}

int main()
{
    int arr[] = {2,6,1,0,4};
    int length = sizeof(arr)/sizeof(int);
    maxHeapSort(arr,length);
    for (int i=0;i<length;i++)
    {
        cout<<arr[i]<<endl;
    }
    return 0;
}