#define _CRT_SECURE_NO_WARNINGS 10#include<stdio.h>#include<stdlib.h>#include<assert.h>#define N 10void SelectSort(int arr[])
{
assert(arr);
int temp = 0;
int i = 0;
int j = 0;
for (i = 0; i<N - 1; i++)
{
temp = i;
for (j = i + 1; j<N; j++)
{
if (arr[j] < arr[temp])
{
temp = j;
}
}
if (temp != i)
{
arr[temp] ^= arr[i];
arr[i] ^= arr[temp];
arr[temp] ^= arr[i];
}
}
}
void Show(int arr[])
{
int i = 0;
for (i = 0; i < N; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
int main()
{
int arr[N] = { 1, 5, 8, 9, 5, 2, 6, 8, 5, 8 };
printf("before:");
Show(arr);
SelectSort(arr);
printf("after: ");
Show(arr);
system("pause");
return0;
}
快速排序
// 快速排序 int GetMidIndex(int* array, int left, int right)
{
int mid = left + ((right-left)>>1);
if (array[left] < array[right])
{
if (array[right] < array[mid])
return right;
elseif (array[left] > array[mid])
return left;
elsereturn mid;
}
else
{
if (array[right] > array[mid])
return right;
elseif (array[left] < array[mid])
return left;
elsereturn mid;
}
}
// 快速排序(前后指针版本) int Partion1(int* array, int left, int right)
{
// // prev指向比key大的前一个位置 // cur向前寻找比key小的数据。 // int keyIndex = GetMidIndex(array, left, right);
if (keyIndex != right)
{
swap(array[keyIndex], array[right]);
}
int key = array[right];
int prev = left - 1;
int cur = left;
while (cur < right)
{
// 找到比key的小的数据则与前面的数据进行交换 if(array[cur] < key && ++prev != cur)
swap(array[cur], array[prev]);
++cur;
}
swap(array[++prev], array[right]);
return prev;
}
// 快速排序(Hoare版本) int Partion2(int* array, int left, int right)
{
int keyIndex = GetMidIndex(array, left, right);
if (keyIndex != right)
{
swap(array[keyIndex], array[right]);
}
int key = array[right];
int begin = left;
int end = right;
while (begin < end)
{
// 从左往右找到比key大的数据时停下 while (array[begin] <= key && begin < end)
++begin;
// 从右往左找到比key小的数据时停下 while (array[end] >= key && begin < end)
--end;
// 若位置还没有交错,则交换着两个数据。 if (begin < end)
swap(array[begin], array[end]);
}
if (begin != right)
swap(array[begin], array[right]);
return begin;
}
// 快速排序(挖坑法) int Partion3(int* array, int left, int right)
{
// 三数取中 int keyIndex = GetMidIndex(array, left, right);
if (keyIndex != right)
swap(array[keyIndex], array[right]);
// key取最后一个数据 int key = array[right];
int begin = left;
int end = right; // end作为第一个坑 while (begin < end)
{
// 从左往右找到比key大的数据时停下 while (array[begin] <= key && begin < end)
++begin;
// 找到一个比key大的数填到end,形成一个新的坑begin if (begin < end)
array[end--] = array[begin];
// 从右往左找到比key小的数据时停下 while (array[end] >= key && begin < end)
--end;
// 找到一个比key小的数填到begin,形成一个新的坑end if (begin < end)
array[begin++] = array[end];
}
// 将key填到最后留下的坑 array[end] = key;
return begin;
}
void QuickSort(int* array, int left, int right)
{
if (left < right)
{
int boundary = Partion3(array, left, right);
QuickSort(array, left, boundary - 1);
QuickSort(array, boundary + 1, right);
}
}
// 非递归实现 void QuickSort_NonRecursive(int* array, int left, int right)
{
stack<int> s;
// 注意先入栈右边界,再入栈边界
s.push(right);
s.push(left);
while(!s.empty())
{
left = s.top();
s.pop();
right = s.top();
s.pop();
if (left < right)
{
int boundary = Partion3(array, left, right);
s.push(boundary - 1);
s.push(left);
s.push(right);
s.push(boundary + 1);
}
}
}
int main()
{
cout<<"QuickSort:"<<endl;
intarray[SIZE] = {2, 5, 4, 9, 3, 6, 8, 7, 1, 0};
PrintArray(array, SIZE);
// QuickSort(array, 0, SIZE - 1); // QuickSort_NonRecursive(array, 0, SIZE - 1);
QuickSort_OP(array, 0, SIZE - 1);
PrintArray(array, SIZE);
return0;
}
插入排序
void InsertSort(int* array, int size)
{
assert(array);
for (int index = 1; index < size; ++index)
{
// 将当前数据往前插入 int end = index - 1;
int tmp = array[index];
while (end >= 0 && tmp < array[end])
{
array[end + 1] = array[end];
--end;
}
// 注意这里的位置 array[end + 1] = tmp;
}
}
“shell”法
void ShellSort(int* array, int size)
{
int gap = size;
while (gap > 1)
{
// Knuth提出的增量效果更好
gap = gap/3 + 1;
// 单次以gap为增量进行插入排序 for (int cur = gap; cur < size; ++cur)
{
int end = cur - gap;
int tmp = array[cur];
while (end >= 0 && tmp < array[end])
{
array[end + gap] = array[end];
end -= gap;
}
array[end + gap] = tmp;
}
}
}