//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);
}
}