排序

void Swap(int* arr,int left, int right)
{
int tmp = arr[left];
arr[left] = arr[right];
arr[right] = tmp;
}
void InsertSort(int* a, int n)
{
int tmp;
int j;
for (int i = 1; i < n; ++i)
{
tmp = a[i];
for (j = i; j >= 1 && a[j - 1] > tmp; --j)
{
a[j] = a[j - 1];
}
a[j] = tmp;
}
}

// 希尔排序
void ShellSort(int* a, int n)
{
int step = n;
int tmp;
int j;
while (step > 1)
{
step /= 2;
for (int i = step; i < n; ++i)
{
tmp = a[i];
for (j = i; j >= step && a[j - step] > tmp; j-=step)
{
a[j] = a[j - step];
}
a[j] = tmp;
}
}
}

// 选择排序
void SelectSort(int* arr, int n)
{
int begin = 0;
int end = n - 1;
while (begin <= end)
{
int big = begin;
int small = begin;
for (int i = begin; i <= end; i++)
{
if (arr[i] >= arr[big])
{
big = i;
}
if (arr[i] < arr[small])
small = i;
}
Swap(arr, small, begin);
if (big == 0)
{
big = small;
}
Swap(arr, big, end);
begin++;
end–;
}
}

// 堆排序
void AdjustDwon(int* arr, int parent, int len)
{
int child = parent * 2 + 1;
while (child < len)
{
if (child + 1 < len && arr[child + 1]>arr[child])
{
child = child + 1;
}
if (arr[child] > arr[parent])
{
Swap(arr, child, parent);
parent = child;
child = parent * 2 + 1;
}
else
return;
}
}
void HeapSort(int* arr, int len)
{
for (int i = (len - 2) / 2; i >= 0; --i)
{
AdjustDwon(arr, i, len);
}
while (len > 1)
{
Swap(arr, len - 1, 0);
len–;
AdjustDwon(arr, 0, len);
}
}

// 冒泡排序
void BubbleSort(int* arr, int len)
{
int flag = 0;
for (int i = 0; i < len - 1; ++i)
{
flag = 0;
for (int j = 0; j < len - 1 - i; ++j)
{
if (arr[j] > arr[j + 1])
{
Swap(arr, j, j + 1);
flag = 1;
}
}
if (flag == 0)
break;
}
}

// 快速排序递归实现
// 快速排序hoare版本
int Mid(int* arr, int left, int mid, int right)
{
if (arr[left] < arr[right])
{
if (arr[mid] < arr[left])
{
return left;
}
else if (arr[mid] > arr[right])
{
return right;
}
else
return mid;
}
else if(arr[left]>arr[right])
{
if (arr[mid] < arr[right])
{
return right;
}
else if (arr[mid]>arr[left])
{
return left;
}
else
return mid;
}
else
return left;
}
int PartSort1(int* arr, int left, int right)
{
int mid = left + (right - left) / 2;
Swap(arr, left, mid);
int base = left;
while (left < right)
{
while (left < right && arr[right] >= arr[base])
–right;
while(left<right&&arr[left]<=arr[base])
++left;
Swap(arr, left, right);
}
Swap(arr, left, base);
return left;
}
// 快速排序挖坑法
int PartSort2(int* arr, int left, int right)
{
int mid = left + (right - left) / 2;
Swap(arr, left, Mid(arr, left, mid, right));
int base = arr[left];
while (left < right)
{
while (left < right && arr[right] >= base)
–right;
arr[left] = arr[right];
while (left < right && arr[left] <= base)
++left;
arr[right] = arr[left];
}
arr[left] = base;
return left;
}
快速排序前后指针法
int PartSort3(int* arr, int left, int right)
{
int pre = left;
int cur = pre + 1;
int base = arr[left];
while (cur <= right)
{
if (arr[cur] < base && ++pre != cur)
{
Swap(arr, pre, cur);
}
++cur;
}
Swap(arr, pre, left);
return pre;
}
void QuickSort(int* arr, int left, int right)
{
if (left >= right)
return;
int mid = PartSort3(arr, left, right);
QuickSort(arr, left, mid - 1);
QuickSort(arr, mid + 1, right);
}

// 快速排序 非递归实现
void QuickSortNonR(int* arr, int left, int right)
{
stacksk;
if (left < right)
{
sk.push(right);
sk.push(left);
}
while (!sk.empty())
{
left = sk.top();
sk.pop();
right = sk.top();
sk.pop();
int mid = PartSort1(arr, left, right);
if (right > mid + 1)
{
sk.push(right);
sk.push(mid + 1);
}
if (left < mid - 1)
{
sk.push(mid - 1);
sk.push(left);
}
}
}

// 归并排序递归实现
void merage(int* arr, int left, int mid, int right, int* help)
{
int begin1 = left;
int end1 = mid;
int begin2 = mid + 1;
int end2 = right;
int idx = 0;
while (begin1 <= end1 && begin2 <= end2)
{
if (arr[begin1] <= arr[begin2])
{
help[idx++] = arr[begin1++];
}
else
help[idx++] = arr[begin2++];
}
while (begin1 <= end1)
{
help[idx++]=arr[begin1++];
}
while (begin2 <= end2)
{
help[idx++] = arr[begin2++];
}
memcpy(arr + left, help, sizeof(int) * (right - left + 1));
}
void merageSortQ(int* arr, int left, int right, int* help)
{
if (left + 1 >= right)
return;
int mid = left + (right - left) / 2;
merageSortQ(arr, left, mid, help);
merageSortQ(arr, mid + 1, right, help);
merage(arr, left, mid, right, help);
}
void MergeSort(int* arr, int n)
{
int* help = (int*)malloc(sizeof(int) * n);
merageSortQ(arr, 0, n - 1, help);
}
// 归并排序非递归实现
void MergeSortNonR(int* arr, int n)
{
int* help = (int*)malloc(sizeof(int) * n);
int step = 1;
int left, mid, right;
while (step < n)
{
for (int i = 0; i < n; i += 2 * step)
{
left = i;
mid = i + step - 1;
if (mid >= n)
break;
right = i + 2 * step - 1;
if (right >= n)
right = n - 1;
merage(arr, left, mid, right, help);
}
step *= 2;
}
}

// 计数排序
void CountSort(int* a, int n)
{
if (a == NULL)
{
return;
}
int max = a[0];
int min = a[0];
for (int i = 0; i < n; i++)
{
if (a[i] > max)
max = a[i];
if (a[i] < min)
min = a[i];
}
int len = max - min + 1;
int* map = (int*)malloc(sizeof(int) * len);
memset(map, 0, sizeof(int) * len);
for (int i = 0; i < n; ++i)
{
map[a[i]-min]++;
}
int idx = 0;
for (int i = 0; i < len; i++)
{
while (map[i]–)
{
a[idx++] = i + min;
}
}
}