1 交换排序
1.1 冒泡排序
从下往上（从后往前）比较，如果发现下面的比上面的小（轻），则交换二者的位置。利用哨兵（见注释部分），某趟没有任何交换则表明所有都排好序，退出。稳定排序，时间复杂度为0(n^2)。
// 冒泡排序, 升序排列
void Swap(int& a, int& b)
{
int t = a;
a = b;
b = t;
}
void BubbleSort(int arrary[], int len)
{
// bool exchange;
for (int i=0; i<len-1; i++) // 最多做n-1趟排序
{
// exchange = false;
for (int j=len-1; j>i; j--)
{
if (arrary[j] < arrary[j-1])
{
// exchange = true;
Swap(arrary[j], arrary[j-1]);
}
}
// if (!exchange)
// {
// break;
// }
}
}
1.2 快速排序
它采用了一种分治的策略，通常称其为分治法。分治法的基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。
在数组中选中一个记录作为基准，将数组分成左右两个子区间，使得左边的值小于等于基准，右边的值大于等于基准。递归调用快速排序对左右两个子区间进行排序。不稳定排序，时间复杂度0(n*log(n))。
int Partition(int arr[], int low, int high)
{
int pivot = arr[low];
while (low < high)
{
while (low < high && arr[high] >= pivot)
--high;
if (low != high)
Swap(arr[low], arr[high]);
while (low < high && arr[low] <= pivot)
++low;
if (low != high)
Swap(arr[low], arr[high]);
}
return low;
}
void QuickSort(int arr[], int low, int high)
{
if (low < high)
{
int n = Partition(arr, low, high);
QuickSort(arr, low, n);
QuickSort(arr, n+1, high);
}
}
2 插入排序
2.1 直接插入排序
每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序中的适当位置，直到全部记录插入完成为止。稳定排序，时间复杂度0（n^2）。
void InsertSort(int arr[], int len)
{
int j;
int tmp;
for (int i=1; i<len; i++)
{
if (arr[i] < arr[i-1])
{
tmp = arr[i];
j = i-1;
do
{
arr[j+1] = arr[j];
j --;
} while (j>=0 && arr[j]>tmp);
arr[j+1] = tmp;
}
}
}
2.2 希尔排序
希尔排序是对插入排序的改进，它每次排序把序列的元素按照某个增量分成几个子序列，对这几个子序列进行插入排序，然后不断的缩小增量扩大每个子序列的元素数量，直到增量为1的时候子序列就和原先的待排列序列一样了，此时只需要做少量的比较和移动就可以完成对序列的排序了。不稳定排序，时间复杂度0(n^(1+m))。注：0<m<1。
// 增量从数组长度的一半开始,每次减小一倍
void ShellSort(int arr[], int len)
{
int temp;
for (int d = len/2; d>0; d /= 2)
{
for (int i=d; i<len; i++)
{
temp = arr[i];
for (int j=i; j>=d; j-=d)
{
if (temp < arr[j-d])
{
arr[j] = arr[j-d];
}
else
{
break;
}
}
arr[j] = temp;
}
}
}
3 选择排序
3.1 直接选择排序
每一趟从待排序的记录中选出关键字最小的记录，顺序放在已排好序的子文件的最后，直到全部记录排序完毕。非稳定排序，时间复杂度为0(n^2)。
void SelectSort(int arr[], int len)
{
int k;
for (int i=0; i<len; i++)
{
k = i;
for (int j=i+1; j<len; j++)
{
if (arr[i] > arr[j])
{
k = j;
}
}
if (k != i)
{
Swap(arr[i], arr[k]);
}
}
}
3.2 堆排序
n个关键字序列Kl，K2，…，Kn称为堆(Heap)，当且仅当该序列满足如下性质(简称为堆性质)：Ki≤K2i且ki≤K2i+1 或 Ki≥K2i且Ki≥K2i+1(1≤i≤ n)。注若索引从0开始，则是：Ki≤K2i+1且Ki≤K2i+2 或 Ki≥K2i+1且Ki≥K2i+2(0≤i≤ n-1)。节点i的父节点为floor(i/2)或floor((i-1)/2)。
若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。 (即如果按照线性存储该树，可得到一个不下降序列或不上升序列)。不稳定排序，时间复杂度0(nlogn)。
// start表示数组从0或1开始
void MaxHeapify(int arr[], int start, int end, int i)
{
int lChild = (start==0) ? (2*i+1) : (2*i);
int rChild = (start==0) ? (2*i+2) : (2*i+1);
int larger = i;
if (lChild<=end && arr[lChild]>arr[i])
{
larger = lChild;
}
if (rChild<=end && arr[rChild]>arr[larger])
{
larger = rChild;
}
if (larger != i)
{
Swap(arr[larger], arr[i]);
MaxHeapify(arr, start, end, larger);
}
}
void BuildMaxHeap(int arr[], int start, int end)
{
int i = (start==0) ? ((end-1)/2) : (end/2);
for (; i>=start; i--)
{
MaxHeapify(arr, start, end, i);
}
}
// 堆排序
void HeapSort(int arr[], int start, int end)
{
// build heap
BuildMaxHeap(arr, start, end);
// 依次将第一个与最后一个交换，然后保持堆性质
// 这样就得到了升序排列
while(end>start)
{
Swap(arr[start], arr[end]);
end--;
MaxHeapify(arr, start, end, start);
}
}
4 归并排序
把待排序序列分成相同大小的两个部分,依次对这两部分进行归并排序,完毕之后再按照顺序进行合并。稳定排序，时间复杂度0(nlogn)。
void Merge(int arr[], int start, int mid, int end)
{
int n1 = mid-start+1;
int n2 = end-mid;
int* arr1 = new int[n1+1];
int* arr2 = new int[n2+1];
// 设置最后一个值为int最大值
arr1[n1] = 2147483647;
arr2[n2] = 2147483647;
int i,j,k;
for (i=0; i<n1; i++)
{
arr1[i] = arr[start+i];
}
for (i=0; i<n2; i++)
{
arr2[i] = arr[mid+i+1];
}
for (k=start,i=0,j=0; k<=end; k++)
{
if (arr1[i] <= arr2[j])
{
arr[k] = arr1[i++];
}
else
{
arr[k] = arr2[j++];
}
}
delete arr1;
delete arr2;
}
void MergeSort(int arr[], int start, int end)
{
if (start < end)
{
int mid = (start+end)/2;
MergeSort(arr, start, mid);
MergeSort(arr, mid+1, end);
Merge(arr, start, mid, end);
}
}
235
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
