introduction to algorithms 菜鸟笔记 sort algorithms

//author:yydrewdrew

#define  NULL (0L)

#define ERROR -1
typedef unsigned int  uint;
typedef uint size_t;

template <class T>
typedef bool(*compare)(const T &a,const T &b);
template <class T>
bool F(const T &a,const T &b)
{
 return(a > b);
}

template <class T>
void Swap(T &x,T &y)
{
 T tem = x;
 x = y;
 y = tem;
 return;
}
template <class T>
inline T min(const T &a,const T &b)
{
 return(a > b ? a:b);
}
template<class T>
inline T max(const T &a,const T &b)
{
 return(a > b ? a:b);
}
////////////////////////////////////////////////////////////////////////////////////////////
template <class T>
void SelectionSort(T *array,const size_t length)
{
 if (array == NULL || length <= 1)
 {
  return;
 }
 size_t i = 1;
 size_t max = 0;
 while (i < length)
 {
  if (array[i] < array[max])
  {
   max = i;
  }
  ++i;
 }
 Swap(array[0],array[max]);
 SelectionSort(array + 1,length - 1);
 return;
}
////////////////////////////////////////////////////////////////////////////////////////////
template <class T>
void InsertionSort(T *array,const size_t length/*,compare f/ * = F* /*/)
{
 if (array == NULL || length <= 1)
 {
  return;
 }
 size_t i = 2;
 while (i < length)
 {
  size_t j = 0;
  while (j < i)
  {
   if (array[i] > array[j])
   {
    T tem = array[i];
    size_t tem_i = i;
    while (tem_i > j)
    {
     array[tem_i] = array[tem_i - 1];
     --tem_i;
    }
    array[j] = tem;
    break;
   }
   ++j;
  }
  ++i;
 }
 return;
}
////////////////////////////////////////////////////////////////////////////////////////////////
template <class T>
void ArrayCpy(T *des,T *src,const size_t length)
{
 if (des == NULL || src == NULL || length == 0)
 {
  return;
 }
 size_t i = 0;
 while (i < length)
 {
  des[i] = src[i];
  ++i;
 }
}

template <class T>
void Merge(T *array,const size_t p,const size_t q,const size_t r)
{
 T *arraytem = new T[q - p + 1];
 int start = p,end = q;
 int i = p,j = r + 1,k = 0;
 while (!(i == r + 1 && j == end + 1))
 {
  if (i > r)
  {
   ArrayCpy(arraytem + k,array + j,end - j + 1);
   break;
  }
  else if (j > end)
  {
   ArrayCpy(arraytem + k,array + i,r - i + 1);
   break;
  }
  if (array[i] >= array[j])
  {
   arraytem[k++] = array[j];
   if (j <= end)
   {
    ++j;
   }
  }
  else
  {
   arraytem[k++] = array[i];
   if (i <= r)
   {
    ++i;
   }
  }
 }
 ArrayCpy(array + p,arraytem,q - p + 1);
 delete []arraytem;
 return;
}

template <class T>
void MergeSort(T *array,const size_t p,const size_t q)
{
 if (array == NULL || p >= q)
 {
  return;
 }
 MergeSort(array,p,(p + q)/2);
 MergeSort(array,(p + q)/2 + 1,q);
 Merge(array,p,q,(p + q)/2);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
template <class T>
void BubbleSort(T *array,const size_t length)
{
 if (array == NULL || length <= 0)
 {
  return;
 }
 size_t i = 0;
 while (i < length)
 {
  size_t j = i + 1;
  while (j < length)
  {
   if (array[j] < array[i])
   {
    Swap(array[j],array[i]);
   }
   ++j;
  }
  ++i;
 }
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
template <class T>
int Partion(T *array,const int p,const int r)
{
 const T tem = array[r];
 int j = p,i = p - 1;
 while (j < r)
 {
  if (array[j] < tem)
  {
   ++i;
   if (i != j)
   {
    Swap(array[i],array[j]);
   }
  }
  ++j;
 }
 Swap(array[++i],array[r]);
 return i;
}

template <class T>
void QuickSort(T *array,int p,int r)
{
 if (array == NULL || p >= r)
 {
  return;
 }
 int q = Partion(array,p,r);
 QuickSort(array,p,q - 1);
 QuickSort(array,q + 1,r);
 return;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define PARENT(i)  ((i) / 2)
#define LEFT(i)    ((i) * 2)
#define RIGHT(i)   ((i) * 2 + 1)
#define RELOCAL(i) ((i) - 1)
template <class T>
void MaxHeapify(T *array,const size_t length,const size_t i)
{
 if (NULL == array || length == 0 || 0 == i || i > length)
 {
  return;
 }
 if (LEFT(i) <= length)
 {
  if(array[RELOCAL(i)] < array[RELOCAL(LEFT(i))])
  {
   Swap(array[RELOCAL(i)],array[RELOCAL(LEFT(i))]);
  }
 }
 if (RIGHT(i) <= length)
 {
  if (array[RELOCAL(i)] < array[RELOCAL(RIGHT(i))])
  {
   Swap(array[RELOCAL(i)],array[RELOCAL(RIGHT(i))]);
  }
 }
 MaxHeapify(array,length,LEFT(i));
 MaxHeapify(array,length,RIGHT(i));
 return;
}
template <class T>
void BuildMaxHeap(T *array,const size_t length)
{
 if (array == NULL || length <= 1)
 {
  return;
 }
 size_t i = length/2;
 while (i != 0)
 {
  MaxHeapify(array,length,i);
  --i;
 }
 return;
}
template <class T>
void HeapSort(T *array,const size_t length)
{
 if (array == NULL || length <= 1)
 {
  return;
 }
 BuildMaxHeap(array,length);
 size_t  l = length;
 while (l != 0)
 {
  swap(array[0],array[RELOCAL(l)]);
  --l;
  MaxHeapify(array,l,1);
 }
 return;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define ERROR -1
template <class T>
int SelectPartion(T *array,const int p,const int r)
{
 const T tem = array[r];
 int i = p - 1;
 int j = p;
 while (j < r)
 {
  if (array[j] >= tem)
  {
   ++i;
   if (i != j)
   {
    Swap(array[i],array[j]);
   }
  }
  ++j;
 }
 Swap(array[++i],array[r]);
 return i;
}
template <class T>
int Select(T *array,const int p,const int r,const int n)
{
 if (array == NULL || n > r || n <= 0 || r <= p)
 {
  throw ERROR;
 }
 const int i = SelectPartion(array,p,r);
 const int k = i - p + 1;
 if (n == k)
 {
  return array[i];
 }
 if (n < k)
 {
  return Select(array,p,i - 1,n);
 }
 if (n > k)
 {
  return Select(array,i + 1,r,n - k);
 }
}