几种常见内部排序算法分析与实现(C语言描述)
<<几种常见内部排序算法分析与实现(C语言描述)>>
Tags: alg,c,blog,book,linux
1. 插入排序
1.1 算法思想
插入排序算法的主要思想是:
1) 把要排序的序列分为两部分: 已排序部分(A)和未排序部分(B); 由于已排序部分和未
排序部分有显示的位置分隔, 我们也可以将已排序部分称之为序列的前部分, 将未排
序 部分称之为序列的后部分. 显然在算法开始前, 已排序部分为空, 未排序部分为
整个待排序序列.
2) 从B中取第一个元素(b), 然后从后往前依次从A中取出元素(a)与b比较, 若b a往后移动一个位置; 否则, 为b找到了其正确位置(a的位置的下一个位置), 把b放入
该位置(记住: A是已经排序好的).
3) 对A增加一个元素: b, 对B减少一个元素: b.
4) 重复 2 - 3 步骤, 直至B为空.
1.3 算法复杂度分析
从插入排序的算法思想中, 我们很容易得知其空间复杂度为 O(1), 时间复杂度为 O(N^2).
2. 选择排序
2.1 算法思想
选择排序算法的主要思想是:
1) 把要排序的序列分为两部分: 已排序部分(A)和未排序部分(B); 由于已排序部分和未
排序部分有显示的位置分隔, 我们也可以将已排序部分称之为序列的前部分, 将未排
序部分称之为序列的后部分. 显然在算法开始前, 已排序部分为空, 未排序部分为整
个待排序序列.
2) 遍历B中的每一个元素, 找到B中的最小元素(b), 把b与A之后的那个元素交换.
3) 对A增加一个元素: b, 对B减少一个元素: b.
4) 重复 2 - 3 步骤, 直至B为空.
2.2 实现
选择排序的空间复杂度为 O(1), 时间复杂度为 O(N^2).
3. 冒泡排序
3.1 算法思想
冒泡排序算法的主要思想是:
1) 把要排序的序列分为两部分: 已排序部分(A)和未排序部分(B); 由于已排序部分和未排
序部分有显示的位置分隔, 我们也可以将已排序部分称之为序列的前部分, 将未排序
部分称之为序列的后部分. 显然在算法开始前, 已排序部分为空, 未排序部分为整个
待排序序列.
2) 对B进行从后往前遍历, 取所有相邻的两个元素对(b1和b2, b1较靠后, b2较靠前)作比
较; 若b1(b) 即放
置到了正确的位置上.
3) 对A增加一个元素: b, 对B减少一个元素: b.
4) 重复 2 - 3 步骤, 直至B为空.
3.2 实现
3.3 算法复杂度分析
冒泡排序的空间复杂度为 O (1), 时间复杂度为 O (N^2).
4. 合并排序
4.1 算法思想
1) 将序列分为两个子序列.
2) 对两个子序列递归地进行合并排序.
3) 把此两个子序列 (已排序)合并为一个有序序列.
4.2 实现
4.3 算法复杂度分析
归并排序算法是运用分治思想的典范, 其空间复杂度为 O(N), 时间复杂度为 O(NlogN).
5. 快速排序
5.1 算法思想
1) 从输入序列中任意选取一个元素(k)作枢纽元;
2) 遍历整个序列, 对于小于等于k的元素放在左边(L), 对于大于k的元素放在右边(R);
3) 对子序列L和R递归地进行快速排序; 直到序列中只有一个若零个元素, 退出递归.
5.2 实现
5.3 算法复杂度分析
Tags: alg,c,blog,book,linux
1. 插入排序
1.1 算法思想
插入排序算法的主要思想是:
1) 把要排序的序列分为两部分: 已排序部分(A)和未排序部分(B); 由于已排序部分和未
排序部分有显示的位置分隔, 我们也可以将已排序部分称之为序列的前部分, 将未排
序 部分称之为序列的后部分. 显然在算法开始前, 已排序部分为空, 未排序部分为
整个待排序序列.
2) 从B中取第一个元素(b), 然后从后往前依次从A中取出元素(a)与b比较, 若b
该位置(记住: A是已经排序好的).
3) 对A增加一个元素: b, 对B减少一个元素: b.
4) 重复 2 - 3 步骤, 直至B为空.
1.2 实现
// #c---
/*==========================================================================*
* @Description:
* 插入排序
*
* @Param base
* @Param nmemb
* @Param size
* @Param compar
*==========================================================================*/
void Sort_insertSort(void *base, size_t nmemb, size_t size,
int(*compar)(const void *, const void *))
{
#define SWAP(a, b, t) ( (t)=(a), (a)=(b), (b)=(t) )
assert(base != NULL && nmemb >= 1 && size >= 1 && compar != NULL);
char *i, *j, t, *b, *e;
char *bot = (char*)base;
char *top = bot + nmemb * size;
for ( i = bot + size; i < top; i += size )
{
for ( j = i; (j-=size) >= bot && compar(i, j) < 0; )
{ }
if ( i != (j+=size) )
{
for ( b = j, e = i-1; b < e; b++, e-- )
SWAP(*b, *e, t);
for ( b = i, e = i+size-1; b < e; b++, e-- )
SWAP(*b, *e, t);
for ( b = j, e = i+size-1; b < e; b++, e-- )
SWAP(*b, *e, t);
}
}
#undef SWAP
}
// #c---end
1.3 算法复杂度分析
从插入排序的算法思想中, 我们很容易得知其空间复杂度为 O(1), 时间复杂度为 O(N^2).
2. 选择排序
2.1 算法思想
选择排序算法的主要思想是:
1) 把要排序的序列分为两部分: 已排序部分(A)和未排序部分(B); 由于已排序部分和未
排序部分有显示的位置分隔, 我们也可以将已排序部分称之为序列的前部分, 将未排
序部分称之为序列的后部分. 显然在算法开始前, 已排序部分为空, 未排序部分为整
个待排序序列.
2) 遍历B中的每一个元素, 找到B中的最小元素(b), 把b与A之后的那个元素交换.
3) 对A增加一个元素: b, 对B减少一个元素: b.
4) 重复 2 - 3 步骤, 直至B为空.
2.2 实现
// #c---
/*==========================================================================*
* @Description:
* 选择排序
*
* @Param base
* @Param nmemb
* @Param size
* @Param compar
*
*==========================================================================*/
void Sort_selectSort(void *base, size_t nmemb, size_t size,
int(*compar)(const void *, const void *))
{
#define SWAP(a, b, t) ( (t)=(a), (a)=(b), (b)=(t) )
assert(base != NULL && nmemb >= 1 && size >= 1 && compar != NULL);
int s;
char t, *i, *j, *min;
char *left = base;
char *right = left + (nmemb - 1) * size;
for ( i = left; i <= right - size; i += size )
{
min = i;
for ( j = i + size; j <= right; j += size )
{
if ( compar(j, min) < 0 )
min = j;
}
if ( i != min )
for ( s = 0; s < size; s++ )
SWAP(*(i+s), *(min+s), t);
}
#undef SWAP
}
// #c---end
选择排序的空间复杂度为 O(1), 时间复杂度为 O(N^2).
3. 冒泡排序
3.1 算法思想
冒泡排序算法的主要思想是:
1) 把要排序的序列分为两部分: 已排序部分(A)和未排序部分(B); 由于已排序部分和未排
序部分有显示的位置分隔, 我们也可以将已排序部分称之为序列的前部分, 将未排序
部分称之为序列的后部分. 显然在算法开始前, 已排序部分为空, 未排序部分为整个
待排序序列.
2) 对B进行从后往前遍历, 取所有相邻的两个元素对(b1和b2, b1较靠后, b2较靠前)作比
较; 若b1
置到了正确的位置上.
3) 对A增加一个元素: b, 对B减少一个元素: b.
4) 重复 2 - 3 步骤, 直至B为空.
3.2 实现
// #c---
/*==========================================================================*
* @Description:
* 冒泡排序
*
* @Param base
* @Param nmemb
* @Param size
* @Param compar
*
*==========================================================================*/
void Sort_bubbleSort(void *base, size_t nmemb, size_t size,
int(*compar)(const void *, const void *))
{
#define SWAP(a, b, t) ( (t)=(a), (a)=(b), (b)=(t) )
assert(base != NULL && nmemb >= 1 && size >= 1 && compar != NULL);
int s, isSwap;
char t, *i, *j;
char *left = base;
char *right = base + (nmemb - 1) * size;
for ( i = left; i < right; i += size )
{
isSwap = 0;
for ( j = right; j > i; j -= size )
{
if ( compar(j, j-size) < 0 )
{
isSwap = 1;
for ( s = 0; s < size; s++ )
SWAP(*(j+s), *(j-size+s), t);
}
}
if ( isSwap == 0 )
break;
}
#undef SWAP
}
// #c---end3.3 算法复杂度分析
冒泡排序的空间复杂度为 O (1), 时间复杂度为 O (N^2).
4. 合并排序
4.1 算法思想
1) 将序列分为两个子序列.
2) 对两个子序列递归地进行合并排序.
3) 把此两个子序列 (已排序)合并为一个有序序列.
4.2 实现
// #c---
/*==========================================================================*
* @Description:
* 合并排序之合并例程
*
* @Param left
* @Param center
* @Param right
* @Param size
* @Param compar
* @Param tmparray
*
*==========================================================================*/
static void SortST_memge(char *left, char *center, char *right, int size,
int(*compar)(const void *, const void *), char *tmparray)
{
#define COPY_SIZE(d, s) \
do { \
for ( i = 0; i < size; i++ ) \
*((d) + i) = *((s) + i); \
} while ( 0 )
int i;
char *Lright = center;
char *Rright = right;
char *Lpcur = left;
char *Rpcur = center + size;
char *Tpcur = tmparray;
for ( ; Lpcur <= Lright && Rpcur <= Rright; Tpcur += size )
{
if ( compar(Lpcur, Rpcur) < 0 )
{
COPY_SIZE(Tpcur, Lpcur);
Lpcur += size;
}
else
{
COPY_SIZE(Tpcur, Rpcur);
Rpcur += size;
}
}
for ( ; Lpcur <= Lright; Lpcur += size, Tpcur += size )
COPY_SIZE(Tpcur, Lpcur);
for ( ; Rpcur <= Rright; Rpcur += size, Tpcur += size )
COPY_SIZE(Tpcur, Rpcur);
for ( Lpcur = left; Lpcur <= right; Lpcur += size, tmparray += size )
COPY_SIZE(Lpcur, tmparray);
#undef COPY_SIZE
}
/*==========================================================================*
* @Description:
* 合并排序
*
* @Param left
* @Param right
* @Param size
* @Param compar
* @Param tmparray
*
*==========================================================================*/
static void Sort_mergeSort_priv(char *left, char *right, int size,
int(*compar)(const void *, const void *), char *tmparray)
{
if ( left < right )
{
char *center = left + ((right - left) / size / 2) * size;
Sort_mergeSort_priv(left, center, size, compar, tmparray);
Sort_mergeSort_priv(center + size, right, size, compar, tmparray);
SortST_memge(left, center, right, size, compar, tmparray);
}
}
/*==========================================================================*
* @Description:
* 合并排序驱动例程
*
* @Param base
* @Param nmemb
* @Param size
* @Param compar
*
*==========================================================================*/
void Sort_mergeSort(void *base, size_t nmemb, size_t size,
int(*compar)(const void *, const void *))
{
assert(base != NULL && nmemb >= 1 && size >= 1 && compar != NULL);
char *left = base;
char *right = base + (nmemb - 1) * size;
char *tmparray;
tmparray = malloc(nmemb * size);
if ( tmparray == NULL )
return;
Sort_mergeSort_priv(left, right, size, compar, tmparray);
free(tmparray);
}
// #c---end4.3 算法复杂度分析
归并排序算法是运用分治思想的典范, 其空间复杂度为 O(N), 时间复杂度为 O(NlogN).
5. 快速排序
5.1 算法思想
1) 从输入序列中任意选取一个元素(k)作枢纽元;
2) 遍历整个序列, 对于小于等于k的元素放在左边(L), 对于大于k的元素放在右边(R);
3) 对子序列L和R递归地进行快速排序; 直到序列中只有一个若零个元素, 退出递归.
5.2 实现
// #c---
/*==========================================================================*
* @Description:
* 取三者间的中间值
*
* @Param left
* @Param right
* @Param size
* @Param compar
*
* @Returns:
*==========================================================================*/
static char* Sort_median3(char *left, char *right, int size,
int(*compar)(const void *, const void *))
{
#define SWAP(a, b, t) ( (t)=(a), (a)=(b), (b)=(t) )
int s;
char t;
// char *center = left + (right - left) / 2; // 错误!!
// 每一步计算都必须取整! 才不至于最后的结果位于字节内!
char *center = left + (((right - left) / size) / 2) * size;
if ( compar(left, center) > 0 )
for ( s = 0; s < size; s++ )
SWAP(*(left+s), *(center+s), t);
if ( compar(left, right) > 0 )
for ( s = 0; s < size; s++ )
SWAP(*(left+s), *(right+s), t);
if ( compar(center, right) > 0 )
for ( s = 0; s < size; s++ )
SWAP(*(center+s), *(right+s), t);
for ( s = 0; s < size; s++ )
SWAP(*(center+s), *(right-size+s), t);
return right - size;
#undef SWAP
}
/*==========================================================================*
* @Description:
* 快速排序
*
* @Param left
* @Param right
* @Param size
* @Param compar
*==========================================================================*/
static void Sort_quicklySort_priv(char *left, char *right, int size,
int(*compar)(const void *, const void *))
{
#define SWAP(a, b, t) ( (t)=(a), (a)=(b), (b)=(t) )
int s;
char t, *i, *j, *pivot;
if ( left + SORT_CUTOFF * size <= right )
{
pivot = Sort_median3(left, right, size, compar);
i = left;
j = right - size;
for ( ; ; )
{
for ( i += size; compar(i, pivot) < 0; i += size ) { }
for ( j -= size; compar(j, pivot) > 0; j -= size ) { }
if ( i < j )
{
for ( s = 0; s < size; s++ )
SWAP(*(i+s), *(j+s), t);
}
else
break;
}
for ( s = 0; s < size; s++ )
SWAP(*(i+s), *(right-size+s), t);
Sort_quicklySort_priv(left, i - size, size, compar);
Sort_quicklySort_priv(i + size, right, size, compar);
}
else
Sort_insertSort(left, (right-left)/size + 1, size, compar);
#undef SWAP
}
/*==========================================================================*
* @Description:
* 快速排序驱动例程
*
* @Param base
* @Param nmemb
* @Param size
* @Param compar
*==========================================================================*/
void Sort_quicklySort(void *base, size_t nmemb, size_t size,
int(*compar)(const void *, const void *))
{
assert(base != NULL && nmemb >= 1 && size >= 1 && compar != NULL);
if ( nmemb <= 1 )
return;
if ( nmemb >= SORT_CUTOFF )
Sort_quicklySort_priv(base, base + (nmemb-1)*size, size, compar);
else
Sort_insertSort(base, nmemb, size, compar);
}
// #c---end5.3 算法复杂度分析
快速排序算法也是运用分治思想, 其空间复杂度为 O(1), 时间复杂度为 O(NlogN).