Быстрая сортировка (3 типа рекурсии)
// Pointer排序——快速排序
int ReferencePositionPointer(int* arr, int begin, int end)
{
int prev = begin;
int cur = begin + 1;
int refvalue = arr[begin];
while (cur <= end)
{
if (arr[cur] < refvalue && ++prev != cur)
{
Swap(arr, prev, cur);
}
cur++;
}
Swap(arr, begin, prev);
return prev;
}
void QuickSort(int* arr, int begin, int end)
{
if (begin >= end)
return;
int refposition = ReferencePositionPointer(arr, begin, end);
QuickSort(arr, begin, refposition - 1);
QuickSort(arr, refposition + 1, end);
}
// Hoare排序——快速排序
int ReferencePositionHoare(int* arr, int begin, int end)
{
int mid = midposition(arr, begin, end);
Swap(arr, mid, begin);
int refvalue = arr[begin];
int refposition = begin;
while (begin < end)
{
while (begin < end && arr[end] >= refvalue)
{
end--;
}
arr[begin] = arr[end];
while (begin < end && arr[begin] <= refvalue)
{
begin++;
}
arr[end] = arr[begin];
}
arr[begin] = refvalue;
return begin;
}
void QuickSort(int* arr, int begin, int end)
{
if (begin >= end)
return;
int refposition = ReferencePositionHoare(arr, begin, end);
QuickSort(arr, begin, refposition - 1);
QuickSort(arr, refposition + 1, end);
}
// 三数取中法——快速排序
int midposition(int* arr, int begin, int end)
{
int mid = begin + (end - begin) / 2;
if (arr[begin] > arr[mid])
{
if (arr[mid] > arr[end])
{
return mid;
}
else if (arr[begin] > arr[end])
{
return end;
}
else
return begin;
}
else
{
if (arr[end] > arr[mid])
return mid;
else if (arr[begin] > arr[mid])
return begin;
else
return end;
}
}
// 获取基准位置——快速排序
int ReferencePosition(int* arr, int begin, int end)
{
int mid = midposition(arr, begin, end);
Swap(arr, mid, begin);
int refvalue = arr[begin];
int refposition = begin;
while (begin < end)
{
while (begin < end && arr[end] >= refvalue)
{
end--;
}
while (begin < end && arr[begin] <= refvalue)
{
begin++;
}
Swap(arr, begin, end);
}
Swap(arr, refposition, begin);
return begin;
}
// 快速排序法 O(n^2)
// 数据有序时,可能会出现栈溢出
// 优化方法:三数取中法
// 优化后 O(nlogn) 相当于栈的调用层数
void QuickSort(int* arr, int begin, int end)
{
if (begin >= end)
return;
int refposition = ReferencePosition(arr, begin, end);
QuickSort(arr, begin, refposition - 1);
QuickSort(arr, refposition + 1, end);
}
Быстрая сортировка (нерекурсивная)
// 非递归快速排序——保存每个子区间——优点:不会导致栈溢出
// 顺序表实现
int ReferencePositionNonRecursion(int* arr, int n)
{
seqList sq;
initseqList(&sq);
seqListPushBack(&sq, n - 1);
seqListPushBack(&sq, 0);
while (!seqListEmpty(&sq))
{
int left = seqListBack(&sq);
seqListPopBack(&sq);
int right = seqListBack(&sq);
seqListPopBack(&sq);
int div = ReferencePosition(arr, left, right);
if (left < div - 1)
{
seqListPushBack(&sq, div - 1);
seqListPushBack(&sq, left);
}
if (div + 1 < right)
{
seqListPushBack(&sq, right);
seqListPushBack(&sq, div + 1);
}
}
}
// 非递归快速排序——保存每个子区间——优点:不会导致栈溢出
// 队列实现
void ReferencePositionNonRecursion(int* arr, int n)
{
Queue sq;
QueueInit(&sq);
QueuePush(&sq, 0);
QueuePush(&sq, n - 1);
while (!QueueEmpty(&sq))
{
int left = QueueFront(&sq);
QueuePop(&sq);
int right = QueueFront(&sq);
QueuePop(&sq);
int div = ReferencePosition(arr, left, right);
if (left < div - 1)
{
QueuePush(&sq, left);
QueuePush(&sq, div - 1);
}
if (div + 1 < right)
{
QueuePush(&sq, div + 1);
QueuePush(&sq, right);
}
}
}
Обновление ing