快速排序
void quitSort(int*a, int l, int h) {
if (l >= h) {
return;
}
int low = l;
int high = h;
int key = a[l];
while (low < high) {
while (high > low&&a[high]>key) {
–high;
}
if (low == high) {
break;
}
a[low] = a[high];
while (low < high&&a[low] <= key) {
++low;
}
if (low == high) {
break;
}
a[high] = a[low];
}
a[low] = key;
quitSort(a, l, low – 1);
quitSort(a, low+1, h);
}
选择排序
void selectSort(int*a, int l, int h) {
if (l >= h) {
return;
}
for (int i = l; i < h; ++i) {
int index = i;
for (int j = i + 1; j <= h; ++j) {
if (a[j] < a[index]) {
index = j;
}
}
if (index != i) {
swap(a[i], a[index]);
}
}
}
冒泡排序
void bubbleSort(int*a, int l, int h) {
for (int i = l; i < h; ++i) {
for (int j = l; j < l+h – i; ++j) {
if (a[j] > a[j + 1]) {
swap(a[j], a[j+1]);
}
}
}
}
插入排序
void insertSort(int*a, int l, int h) {
if (l >= h) {
return;
}
for (int i = l + 1; i <= h; ++i) {
int key = a[i];
int pos = i;
while (pos > l&&key < a[pos – 1]) {
a[pos] = a[pos – 1];
–pos;
}
a[pos] = key;
}
}
基数排序
/总体来讲就是根据个十百千万…排序
//先根据个位0-9分成10个桶，然后把所有数据分到10个桶里面去
//属于同一个桶的数据是相邻的
//再根据十位，依次类推，一直到最大的位数(最大的那个数拥有的位数
//，比如最大的数是999，那么最大的位数就是百位)结束，这样所有的数据就能排好序
int maxbit(int data[], int n) //辅助函数，求数据的最大位数
{
int d = 1; //保存最大的位数
int p = 10;
for (int i = 0; i < n; ++i)
{
while (data[i] >= p)
{
p *= 10;
++d;
}
}
return d;
}
void radixsort(int data[], int n) //基数排序
{
int d = maxbit(data, n);
int *tmp = new int[n];
int *count = new int[10]; //计数器
int i, j, k;
int radix = 1;
for (i = 1; i <= d; i++) //进行d次排序
{
for (j = 0; j < 10; j++)
count[j] = 0; //每次分配前清空计数器
for (j = 0; j < n; j++)
{
k = (data[j] / radix) % 10; //统计每个桶中的记录数
count[k]++;
}
for (j = 1; j < 10; j++)
count[j] = count[j – 1] + count[j]; //将tmp中的位置依次分配给每个桶
for (j = n – 1; j >= 0; j–) //将所有桶中记录依次收集到tmp中
{
k = (data[j] / radix) % 10;
tmp[count[k] – 1] = data[j];
count[k]–;
}
for (j = 0; j < n; j++) //将临时数组的内容复制到data中
data[j] = tmp[j];
radix = radix * 10;
}
delete[]tmp;
delete[]count;
}
堆排序
//array是待调整的堆数组，i是待调整的数组元素的位置，nlength是数组的长度
//本函数功能是：根据数组array构建大根堆
void HeapAdjust(int array[], int i, int nLength)
{
int nChild;
int nTemp;
for (; 2 * i + 1<nLength; i = nChild)
{
//子结点的位置=2*（父结点位置）+1
nChild = 2 * i + 1;
//得到子结点中较大的结点
if (nChild<nLength – 1 && array[nChild + 1]>array[nChild])++nChild;
//如果较大的子结点大于父结点那么把较大的子结点往上移动，替换它的父结点
if (array[i]<array[nChild])
{
nTemp = array[i];
array[i] = array[nChild];
array[nChild] = nTemp;
}
else break; //否则退出循环
}
}
//堆排序算法
void HeapSort(int array[], int length)
{
int i;
//调整序列的前半部分元素，调整完之后第一个元素是序列的最大的元素
//length/2-1是最后一个非叶节点，此处”/”为整除
for (i = length / 2 – 1; i >= 0; –i)
HeapAdjust(array, i, length);
//从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
for (i = length – 1; i>0; –i)
{
//把第一个元素和当前的最后一个元素交换，
//保证当前的最后一个位置的元素都是在现在的这个序列之中最大的
array[i] = array[0] ^ array[i];
array[0] = array[0] ^ array[i];
array[i] = array[0] ^ array[i];
//不断缩小调整heap的范围，每一次调整完毕保证第一个元素是当前序列的最大值
HeapAdjust(array, 0, i);
}
}
