算法学习小心得——基于比较的排序算法汇总

这几天学习了基于比较的排序算法，有插入排序、归并排序、堆排序和快速排序。下面自己用C++代码实现了一下：

1、插入排序，插入排序的思想比较简单，就是像我们打扑克牌把手中的牌整理好一样，假设手中的牌是已经排好的，只需要找找到适当的位置把下一张牌插入到已有的牌中就好了。

void InsertionSort(int *A,int beg,int end){
int key;
for(int i=beg+1;i<=end;i++){//对所有的牌进行遍历，假设手中只有一张牌。
key=A[i];//用key来表示要插入的牌
int j=i-1;
while(j>=0 && A[j]>key){//找到正确的位置：如果手中的牌比要插入的大就往后移，直到正确的位置
A[j+1]=A[j];
j--;
}
A[j+1]=key;//把要插入的牌放到正确的位置
}
}

2、归并排序，归并排序使用了分治的方法，即把问题分为若干个子问题再分别解决每个子问题。主要思想是这样的，如果a和b是两个已经排好序的数组，那么可以比较a和b中的元素大小，把他们合并成一个排好序的数组。所以就把整个要排序的数组进行划分，直到每个字数组中只有一个元素（一个元素肯定是排好序的）。然后开始合并，直到最后合并成原长度的数组。这里用了一个Merge作为合并函数。

void Merge(int *A,int beg,int mid,int end){//合并函数
int n1=mid-beg+1,n2=end-mid;
int i1=beg,i2=mid+1;
vector<int> v;//用了一个vector来做中间数组，这里我纯粹是为了练习，完全可以用一个数组
while(i1<=mid && i2<=end){
if(A[i1]<A[i2]){
v.push_back(A[i1++]);
}
else
v.push_back(A[i2++]);
}
while(i1<=mid){
v.push_back(A[i1++]);
}
while(i2<=end){
v.push_back(A[i2++]);
}
int n=beg;
auto it=v.begin();
while(it!=v.end()){//将合并好的数组拷入到原数组中
A[n++]=*it;
it++;
}
}

void MergeSort(int *A,int beg,int end){//进行归并
if(beg<end){//如果数组元素不为1，就进行划分
int mid=beg+(end-beg)/2;
MergeSort(A,beg,mid);
MergeSort(A,mid+1,end);
Merge(A,beg,mid,end);
}
}

3、堆排序，堆排序是使用了最大堆这种数据结构。最大堆就是堆顶的元素是堆中最大的。堆排序的主要思想就是用数组来构造最大堆。这样每次把堆顶元素和数组中最后一个元素调换位置，直到堆中只有一个元素，这样数组的元素就从大到小了。这个算法写了一个堆的类，用成员函数进行排序。

class Maxheap{
private:
int size;//存放堆得大小
int length;//存放数组的长度
vector<int> data;//存放堆中元素
public:
Maxheap(){size=0;length=0;}
void Add(int value){
data.push_back(value);
size++;
length++;
}
void MaxHeapify(int i);
void BuildMaxheap();
void HeapSort();
int Get(int i){if(i<length)return data[i];else cout<<"overflow";}
int Getlen(){return length;}
};

void Maxheap::MaxHeapify(int i){//这个函数用来不断的维护堆的性质，因为建堆的时候需要用到，而且调换了堆顶元素和堆中最后一个元素后会破坏堆的性质。
int l=2*i+1,r=2*i+2;//找到左孩子和又孩子的序号
int largest=i,temp;
if(l<size && data[l]>data[i]){
largest=l;
}
if(r<size && data[r]>data[largest]){
largest=r;
}//将根、左孩子、右孩子中最大的作为根
if(largest!=i){//如果左子树和右子树的根变化，可能破坏了子树的性质，所以再次对子树进行维护。
temp=data[largest];
data[largest]=data[i];
data[i]=temp;
MaxHeapify(largest);
}
}

void Maxheap::BuildMaxheap(){//建堆
size=length;
for(int i=length/2-1;i>=0;i--){//因为对树来说，后n/2节点为叶节点，所以不需要维护，只维护前n/2
MaxHeapify(i);
}
}

void Maxheap::HeapSort(){//排序
BuildMaxheap();//先建堆
int temp;
while(size>1){//然后不断的把堆顶元素移到堆尾，并且维护堆的性质
temp=data[size-1];
data[size-1]=data[0];
data[0]=temp;
size--;
MaxHeapify(0);
}
}

4、快速排序，这个排序相对比较难懂，也是用了分治的策略。把目标数组的最后一个元素作为主元素，然后对前n-1个进行遍历，试数组被分为起点到i，i到j，j到末尾3段，第一段的数都小于主元素，第二段的数都大于主元素，第三段没有排，然后知道第三段的元素都被移除到第一段和第二段。再把主元素和到i+1的位置（大于主元素的位置）的元素调换，这样就被分成了两段，前一段都小于主元素，后一段都大于主元素。再对这两段递归的执行相同算法。

int Partition(int *A,int beg,int end){//用于划分
int key=A[end];
int i=beg-1,j=beg;
int temp;
while(j<end){
if(A[j]<key){
temp=A[++i];
A[i]=A[j];
A[j++]=temp;
}
else
j++;
}
temp=A[++i];
A[i]=A[end];
A[end]=temp;
return i;//返回后i之前的元素都小于A[i]，i之后的都大于A[i]
}

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

除了插入排序的时间复杂度是N平方外，其他都是nlgn，对于快速排序来说这个时间复杂度是平均的，而不是最坏的，当然如果随机的来选取主元素的话，是可以打到更好的效果，这里需要的数学证明比较多，就不说了哈。nlgn也是基于比较排序的算法的时间复杂度下限，也就是最优的。其中归并排序不是原址的，也就是会占用和问题大小相关的存储空间。其他三个算法都是原址的。