排序

typedef int DataType;

template<typename T>
class Sort
{
private:

 static int Partition(T argData[],int sp,int ep);
 //快速排序中调用寻找分治点
 static void shellInsert(T argData[],int dk,long DataLen);
 //希尔排序中调用增量为dk插入排序
 static void mergeInsertSort(T Data[],int DataLen,int PartPoint);
 //归并排序法中调用优化的插入排序

public:

 static void bubbleSort(T Data[],int DataLen);
 //冒泡排序
 static void insertSort(T Data[],int DataLen);
 //直接插入排序
 static void selectionSort(T Data[],int DataLen);
 //简单选择排序
 static void quickSort(T Data[],int sp,int DataLen);
 //快速排序
 static void shellSort(T Data[],int DataLen);
 //希尔排序
 static void mergeSort(T Data[],int DataLen);
 //归并排序法

};

int main()
{
 DataType Data[] = {10,9,8,7,6,5,4,3,2,1,0};

    int DataLen = sizeof(Data)/sizeof(int);

 Sort<DataType>::bubbleSort(Data,DataLen);

 Sort<DataType>::insertSort(Data,DataLen);

 Sort<DataType>::selectionSort(Data,DataLen);

 Sort<DataType>::quickSort(Data,0,DataLen);

 Sort<DataType>::shellSort(Data,DataLen);

 Sort<DataType>::mergeSort(Data,DataLen);

 return 0;
}

template <typename T>
void Sort<T>::bubbleSort(T Data[],int DataLen)
//冒泡排序
{
 T temp;
 for(int i=0 ; i<DataLen ; i++)
 {
  for(int j=0 ; j<DataLen-i ; j++)
  {
   if (Data[j]>Data[j+1])
   {
    temp = Data[j];
    Data[j] = Data[j+1];
    Data[j+1] = temp;
   }
  }
 }
}

template<typename T>
void Sort<T>::insertSort(T Data[],int DataLen)
//直接插入排序
{
 T temp;
 for(int i=1 ; i<DataLen ; i++)
 {
  if(Data[i]<Data[i-1])
  {
   temp = Data[i];
   int j = i;
   do
   {
    Data[j] = Data[j-1];
    j--;
   }while(temp<Data[j] && j>0);
   Data[j] = temp;
  }
 }
}

template<typename T>
void Sort<T>::selectionSort(T Data[],int DataLen)
//简单选择排序
{
 T temp;
 int minIndex;
 for(int i=0 ; i<DataLen ; i++)
 {
  minIndex = i;
  for(int j=i+1 ; j<DataLen ; j++)
  {
   if (Data[minIndex]>Data[j])
   {
    minIndex = j;
   }
  }
  if (minIndex!=i)
  {
   temp = Data[i];
   Data[i] = Data[minIndex];
   Data[minIndex] = temp;
  }
 }
}

template <typename T>
int Sort<T>::Partition(T argData[],int sp,int ep)
{
 int Idx = (ep-sp)/2+sp;
 T pivot = argData[Idx];
 T temp;
 int i = sp - 1;
 int j = ep + 1;
 while(i<j)
 {
  do{i++;}while (argData[i]<pivot);
  do{j--;}while (argData[j]>pivot);
  if(i<j)
  {
   temp = argData[i];
   argData[i] = argData[j];
   argData[j] = temp;
  }
 }
 argData[Idx] = argData[j];
 argData[j] = pivot;
 return j;
}

template <typename T>
void Sort<T>::quickSort(T Data[],int sp, int DataLen)
//快速排序
{
 const int MiniLen = 1;
 if (DataLen<=MiniLen)
 {
 }
 else
 {
  int pivot = Partition(Data,sp,DataLen-1);
  quickSort(Data,0,pivot+1);
  quickSort(Data,pivot+1,DataLen-pivot-1);
 }
}

template <typename T>
void Sort<T>::shellInsert(T argData[],int dk,long DataLen)
{
 T temp;
 for(int i=dk ; i<DataLen ; i++)
 {
  if(argData[i]<argData[i-dk])
  {
   temp = argData[i];
   for(int j=i-dk ; (j>=0)&&(temp<argData[j]) ; j-=dk)
   {
    argData[j+dk] = argData[j];
    argData[j] = temp;
   }
  }
 }
}

template <typename T>
void Sort<T>::shellSort(T Data[],int DataLen)
//希尔排序
{
 if (DataLen<10)
 {
  shellInsert(Data,1,DataLen);
 }
 else
 {
  int dkArray[]={1,2,3,5};
  for(int i=sizeof(dkArray)/sizeof(int)-1 ; i>=0 ; i++)
  {
   shellInsert(Data,dkArray[i],DataLen);
  }
 }
}

template<typename T>
void Sort<T>::mergeInsertSort(T Data[],int DataLen,int PartPoint)
//归并排序中优化的插入排序
{
 int i = PartPoint;
 int j = 0;
 int insertNode = 0;
 T temp;
 while((i<DataLen)&&(j<(PartPoint+insertNode)))
 {
  if(Data[i]>=Data[j]){ j++; }
  else
  {
   //插入
   temp =Data[i];
   for(int k = i ; k>j ; k--)
    Data[k] = Data[k-1];
   Data[j] = temp;
   //
   insertNode++;
   i++;
   j++;
  }
 }
}

template <typename T>
void Sort<T>::mergeSort(T Data[],int DataLen)
//归并排序法
{
 int i=2;
 for( ; i<DataLen ; i*=2)
 {
  for(int j=0 ; j<DataLen ; j+=i)
  {
   mergeInsertSort(&Data[j],(DataLen-j) > i ? i : DataLen-j,i/2);
  }
 }
 mergeInsertSort(Data,DataLen,i/2);
}