复习数据结构和算法01-常用的排序算法

复习数据结构和算法

namespace Sort{

 template<typename _DataType>
 void Swap(_DataType &l, _DataType &r)
 {
  _DataType temp(l);
  l = r;
  r = temp;
 }

 //冒泡排序 升序
 //O(n^2)
 template<typename _DataType>
 void BubbleSort(_DataType data[], int nCount)
 {
  if(nCount<2)
   return;
  int i, j;
  for(i=1; i<nCount-1; i++)
   for(j=0; j<nCount-i; j++)
   {
    if(data[j+1]<data[j])
     Swap(data[j], data[j+1]);
   }
 }

 //及时终止的冒泡排序 升序
 //最好情况 有序 O(n)
 //最坏情况 无序 O(n^2)
 template<typename _DataType>
 void BubbleSort2(_DataType data[], int nCount)
 {
  if(nCount<2)
   return;
  int i, j;
  bool bOK;
  for(i=1; i<nCount-1; i++)
  {
   bOK = true;
   for(j=0; j<nCount-i; j++)
   {
    if(data[j+1]<data[j])
    {
     bOK = false;    
     Swap(data[j], data[j+1]);
    }
   }
   if(bOK)
    break;
  }  
 }

 //选择排序 升序
 template<typename _DataType>
 void SelectionSort(_DataType data[], int nCount)
 {
  if(nCount<2)
   return;
  int i, j, idxMax;
  for(i=0; i<nCount-1; i++)
  {
   idxMax = 0;
   for(j=1; j<nCount-i; j++)
   {
    if(data[idxMax]<data[j])
     idxMax = j;
   }
   Swap(data[idxMax], data[j-1]);
  }
 }

 //插入排序
 //最好情况 数组有序 O(n-1)
 //最坏情况 数组逆序 O(n^2)
 template<typename _DataType>
 void InsertionSort(_DataType data[], int nCount)
 {
  if(nCount<2)
   return;
  int i, j;
  _DataType temp;
  for(i=1; i<nCount; i++)
  {
   temp = data[i];
   for(j=i-1; j>=0 && temp<data[j]; j--)
    data[j+1] = data[j];
   data[j+1] = temp;
  }
 }

 //希尔(Shell)排序   约为n^1.3
 template<typename _DataType>
 void ShellSort(_DataType data[], int nCount)
 {
  if(nCount<2)
   return;
  int i, j;
  int stride = nCount>>1;
  _DataType temp;
  while(stride)
  {
   for(i=0; i<nCount; i+=stride)
   {
    temp = data[i];
    for(j=i-stride; j>=0 && temp<data[j]; j-=stride)
     data[j+stride] = data[j];
    data[j+stride] = temp;
   }
   stride = stride>>1;
  }
  
 }

 //快速排序 data[begin]~data[end](包括data[begin]与data[end])
 //平均时间复杂度 O(nlogn)
 //最坏情况: O(n^2)         完全有序
 //最好情况: 前后段元素个数基本相等, 支点取值接近中值
 template<typename _DataType>
 void _quicksort(_DataType data[], int begin, int end)
 {
  if(begin>=end)
   return;
  int left=begin, right=end+1;
  _DataType pivot(data[begin]);  //
  while(1)
  {
   //左侧找出一个比支点大的值
   do{
    ++left;
   }while(left<=end && data[left]<pivot);
   //右侧找出一个比支点小的值
   do{
    --right;
   }while(begin<=right && data[right]>pivot);

   //交换完毕 跳出循环
   if(left>=right)
    break;
   //交换两侧查找到的值
   Swap(data[left], data[right]);
  }
  
  data[begin] = data[right];
  data[right] = pivot;
  //递归:排序前半段
  _quicksort(data, begin, left-1);
  //递归:排序后半段
  _quicksort(data, right+1, end);
 }

 //快速排序封装函数
 template<typename _DataType>
 void QuickSort(_DataType data[], int nCount)
 {
  if(nCount<2 || NULL==data)
   return;
  _quicksort(data, 0, nCount-1);
 }

};