排序算法（堆排序，归并排序，快排）

最近看数据结构写的两个排序算法,一个归并排序，一个堆排序，本来打算把快速排序也练一下，不过这几天都有点事，而且又忙一下毕设，就没有写，过几天再写；

排序的理论上的时间复杂度的下届是：O（nlogn）；

归并排序的时间复杂度O（nlgn），缺点需要较多的存储空间 ；主要用于外排序

堆排序的时间复杂度O（nlogn），是就地（in place）算法，空间利用少；

 

前天用比较多数据测试时，发现错误了，排不出来，就不断地想哪里错，作了修改了，其中都系仿书上的程序写的，现在懂了这几个算法的奥妙了，哈哈！测试数据用的是随机产生的数

在我机子上对1，000，000个随机数排序，快排5.25s，堆排序9.579s，合并排序L：23s，感觉合并可能出错了，太慢了！看什么时候再看一下先

程序代码：

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

//Merge Sort and HeapSort

template<class T>
void Merge(vector<T>&Table,int m) //m the size of table i the first add of the table
{
 int size = Table.size();
 int i = 0;   //起始点
 int j = i+m;  //起始的第二个表
 int i_init;
 int j_init;
 int j_decision;
 int x;
 vector<T> temp;

 while(j < size)
 {
  i_init = i;
  j_init = j;
  if(size>j_init+m)    //取较小的为判断结束标志
  {
   j_decision = j_init+m;
  }
  else
  {
   j_decision = size;
  }

  while((i<(i_init+m))&&(j<j_decision))  //合并
  {
   if(Table[i]>Table[j])
   {
    temp.push_back(Table[j]);
    j++;
   }
   else if(Table[j]>=Table[i])
   {
    temp.push_back(Table[i]);
    i++;
   }
  }   
  if(j != j_decision)
  {
   for(x = j;x<j_decision;x++)
   {
    temp.push_back(Table[x]);
   }
  }
  else if(i != (i_init+m))
  {
   for(x = i;x<i_init+m;x++)
   {
    temp.push_back(Table[i]);
   }
  }
  i = i_init+2*m;      //调整下标
  j = i+m;
 }
 if(j>=size)        //补充没有进行合并的表
 {
  for(x = i;x<size;x++)
  {
   temp.push_back(Table[x]);
  }
 }
 Table = temp;
}

template<class T>
void MergeSort(vector<T>&Sort)
{
 int m = 1;
 while(m<Sort.size())
 {
  Merge(Sort,m);
  m = m*2;
 }
}

template<class T>
void Swap(T &x1,T &x2)
{
 T temp;
 temp = x1;
 x1 = x2;
 x2 = temp;
}

template<class T>
void HeapChange(vector<T>&Heap,int n,int x)  //x is to make the heap to max(1) or min(0) (default = 0)
{             //n = 要对其堆排序的个数
 int cur = n/2-1;
 if(x == 0)
 {
  for(int i = cur;i>=0;i--)
  {
   if(Heap[i]>Heap[i*2+1])
   {
    Swap(Heap[i],Heap[i*2+1]);
   }
   if((i*2+2) < n)
   {
    if(Heap[i]>Heap[i*2+2])
     Swap(Heap[i],Heap[i*2+2]);
   }
  }
 }
 else
 {
  for(int i = cur;i>=0;i--)
  {
   if(Heap[i]<Heap[i*2+1])
   {
    Swap(Heap[i],Heap[i*2+1]);
   }
   if((i*2+2) < n)
   {
    if(Heap[i]<Heap[i*2+2])
     Swap(Heap[i],Heap[i*2+2]);
   }
  }

 }
}

template<class T>
void HeapSort(vector<T>&Heap,int x = 1)  //1 -> small to big  ;0 -> big to small
{
 int size = Heap.size();
 for(int i = Heap.size()-1;i>0;i--)
 {
  HeapChange(Heap,size,x);
  Swap(Heap[0],Heap[i]);
  size--;
 }
}