直接插入排序代码:
void sort(int a[], int n)
{
int i, j, temp;
for (i = 1; i < n; ++i)
{
temp = a[i];
for (j = i; j > 0 && temp < a[j - 1]; --j)
{
a[j] = a[j - 1];
}
a[j] = temp;
}
}
二分查找的插入排序代码:
void BinarySort(int a[], int n)
{
for (int i = 1; i < n; ++i)
{
int temp, low, high;
temp = a[i];
low = 0;
high = i - 1;
while (low <= high)
{
int mid = (low + high) / 2;
if (temp < a[mid])
high = mid - 1;
else
low = mid + 1;
}
for (int j = i - 1; j >= high + 1; --j)
a[j + 1] = a[j];
a[high + 1] = temp;
}
}
shell排序代码:
void shellsort(int array[], int length)
{
int temp, i, j;
//增量从数组长度的一半开始,每次减小一倍
for (int increment = length / 2; increment > 0; increment /= 2)
for (i = increment; i < length; ++i)
{
temp = array[i];
//对一组增量为increment的元素进行插入排序
for (j = i; j >= increment; j -= increment)
{
//把i之前大于array[i]的数据向后移动
if (temp < array[j - increment])
{
array[j] = array[j - increment];
}
else
{
break;
}
}
//在合适位置安放当前元素
array[j] = temp;
}
}
冒泡排序代码:
void bubblesort(int array[], int n)
{
int i, j, temp;
for (i = 0; i < n - 1; ++i)
{
for (j = 0; j < n - i - 1; ++j)
{
if (array[j] > array[j + 1])
{
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
快速排序代码:
void qsort(int a[], int l, int r)
{
int i, j, temp, x;
i = l, j = r;
x = a[(i + j) / 2];
do
{
while (a[i] < x) i++;
while (x < a[j]) j--;
if (i <= j)
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
i++, j--;
}
} while (i <= j);
if (i < r) qsort(a, i, r);
if (l < j) qsort(a, l, j);
}
直接选择排序代码:
void selectsort(int a[], int n)
{
int i, j, m;
int t;
for (i = 0; i < n; ++i)
{
m = i;
for (j = i + 1; j < n; ++j)
{
if (a[j] < a[m])
m = j;
}
if (m != i)
{
t = a[i];
a[i] = a[m];
a[m] = t;
}
}
}
堆排序代码:
// array是待调整的堆数组,i是待调整的数组元素的位置,length是数组的长度
void HeapAdjust(int array[], int i, int nLength)
{
int nChild, nTemp;
for (nTemp = array[i]; 2 * i + 1 < nLength; i = nChild)
{
// 子结点的位置是 父结点位置 * 2 + 1
nChild = 2 * i + 1;
// 得到子结点中较大的结点
if (nChild != nLength - 1 && array[nChild + 1] > array[nChild])
++nChild;
// 如果较大的子结点大于父结点那么把较大的子结点往上移动,替换它的父结点
if (nTemp < array[nChild])
{
array[i] = array[nChild];
}
else // 否则退出循环
{
break;
}
}
// 最后把需要调整的元素值放到合适的位置
array[i] = nTemp;
}
// 堆排序算法
void HeapSort(int array[], int length)
{
// 调整序列的前半部分元素,调整完之后第一个元素是序列的最大的元素
for (int i = length / 2 - 1; i >= 0; --i)
{
HeapAdjust(array, i, length);
}
// 从最后一个元素开始对序列进行调整,不断的缩小调整的范围直到第一个元素
for (int i = length - 1; i > 0; --i)
{
// 把第一个元素和当前的最后一个元素交换,
// 保证当前的最后一个位置的元素都是在现在的这个序列之中最大的
int temp;
temp = array[0];
array[0] = array[i];
array[i] = temp;
// 不断缩小调整heap的范围,每一次调整完毕保证第一个元素是当前序列的最大值
HeapAdjust(array, 0, i);
}
}
归并排序代码:
void Merge(int array[], int start, int mid, int end)
{
int temp1[10], temp2[10];
int n1, n2;
n1 = mid - start + 1;
n2 = end - mid;
// 拷贝前半部分数组
for (int i = 0; i < n1; ++i)
{
temp1[i] = array[start + i];
}
// 拷贝后半部分数组
for (int i = 0; i < n2; ++i)
{
temp2[i] = array[mid + i + 1];
}
// 把后面的元素设置的很大
temp1[n1] = temp2[n2] = 1000;
// 逐个扫描两部分数组然后放到相应的位置去
for (int k = start, i = 0, j = 0; k <= end; ++k)
{
if (temp1[i] <= temp2[j])
{
array[k] = temp1[i];
i++;
}
else
{
array[k] = temp2[j];
j++;
}
}
}
void MergeSort(int array[], int first, int last)
{
int mid = 0;
if (first < last)
{
mid = (first + last) / 2;
// 对前半部分进行排序
MergeSort(array, first, mid);
// 对后半部分进行排序
MergeSort(array, mid + 1, last);
// 合并前后两部分
Merge(array, first, mid, last);
}
}