C语言库函数qsort源代码

void __fileDECL qsort (

创新互联建站主要从事网页设计、PC网站建设（电脑版网站建设）、wap网站建设（手机版网站建设）、响应式网站、程序开发、网站优化、微网站、微信平台小程序开发等，凭借多年来在互联网的打拼，我们在互联网网站建设行业积累了丰富的成都网站制作、成都网站建设、网站设计、网络营销经验，集策划、开发、设计、营销、管理等多方位专业化运作于一体。

void *base,

size_t num,

size_t width,

int (__fileDECL *comp)(const void *, const void *)

)

#endif /* __USE_CONTEXT */

{

char *lo, *hi; /* ends of sub-array currently sorting */

char *mid; /* points to middle of subarray */

char *loguy, *higuy; /* traveling pointers for partition step */

size_t size; /* size of the sub-array */

char *lostk[STKSIZ], *histk[STKSIZ];

int stkptr; /* stack for saving sub-array to be processed */

/* validation section */

_VALIDATE_RETURN_VOID(base != NULL || num == 0, EINVAL);

_VALIDATE_RETURN_VOID(width 0, EINVAL);

_VALIDATE_RETURN_VOID(comp != NULL, EINVAL);

if (num 2)

return; /* nothing to do */

stkptr = 0; /* initialize stack */

lo = (char *)base;

hi = (char *)base + width * (num-1); /* initialize limits */

/* this entry point is for pseudo-recursion calling: setting

lo and hi and jumping to here is like recursion, but stkptr is

preserved, locals aren't, so we preserve stuff on the stack */

recurse:

size = (hi - lo) / width + 1; /* number of el's to sort */

/* below a certain size, it is faster to use a O(n^2) sorting method */

if (size = CUTOFF) {

__SHORTSORT(lo, hi, width, comp, context);

}

else {

/* First we pick a partitioning element. The efficiency of the

algorithm demands that we find one that is approximately the median

of the values, but also that we select one fast. We choose the

median of the first, middle, and last elements, to avoid bad

performance in the face of already sorted data, or data that is made

up of multiple sorted runs appended together. Testing shows that a

median-of-three algorithm provides better performance than simply

picking the middle element for the latter case. */

mid = lo + (size / 2) * width; /* find middle element */

/* Sort the first, middle, last elements into order */

if (__COMPARE(context, lo, mid) 0) {

swap(lo, mid, width);

}

if (__COMPARE(context, lo, hi) 0) {

swap(lo, hi, width);

}

if (__COMPARE(context, mid, hi) 0) {

swap(mid, hi, width);

}

/* We now wish to partition the array into three pieces, one consisting

of elements = partition element, one of elements equal to the

partition element, and one of elements than it. This is done

below; comments indicate conditions established at every step. */

loguy = lo;

higuy = hi;

/* Note that higuy decreases and loguy increases on every iteration,

so loop must terminate. */

for (;;) {

/* lo = loguy hi, lo higuy = hi,

A[i] = A[mid] for lo = i = loguy,

A[i] A[mid] for higuy = i hi,

A[hi] = A[mid] */

/* The doubled loop is to avoid calling comp(mid,mid), since some

existing comparison funcs don't work when passed the same

value for both pointers. */

if (mid loguy) {

do {

loguy += width;

} while (loguy mid __COMPARE(context, loguy, mid) = 0);

}

if (mid = loguy) {

do {

loguy += width;

} while (loguy = hi __COMPARE(context, loguy, mid) = 0);

}

/* lo loguy = hi+1, A[i] = A[mid] for lo = i loguy,

either loguy hi or A[loguy] A[mid] */

do {

higuy -= width;

} while (higuy mid __COMPARE(context, higuy, mid) 0);

/* lo = higuy hi, A[i] A[mid] for higuy i hi,

either higuy == lo or A[higuy] = A[mid] */

if (higuy loguy)

break;

/* if loguy hi or higuy == lo, then we would have exited, so

A[loguy] A[mid], A[higuy] = A[mid],

loguy = hi, higuy lo */

swap(loguy, higuy, width);

/* If the partition element was moved, follow it. Only need

to check for mid == higuy, since before the swap,

A[loguy] A[mid] implies loguy != mid. */

if (mid == higuy)

mid = loguy;

/* A[loguy] = A[mid], A[higuy] A[mid]; so condition at top

of loop is re-established */

}

/* A[i] = A[mid] for lo = i loguy,

A[i] A[mid] for higuy i hi,

A[hi] = A[mid]

higuy loguy

implying:

higuy == loguy-1

or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */

/* Find adjacent elements equal to the partition element. The

doubled loop is to avoid calling comp(mid,mid), since some

existing comparison funcs don't work when passed the same value

for both pointers. */

higuy += width;

if (mid higuy) {

do {

higuy -= width;

} while (higuy mid __COMPARE(context, higuy, mid) == 0);

}

if (mid = higuy) {

do {

higuy -= width;

} while (higuy lo __COMPARE(context, higuy, mid) == 0);

}

/* OK, now we have the following:

higuy loguy

lo = higuy = hi

A[i] = A[mid] for lo = i = higuy

A[i] == A[mid] for higuy i loguy

A[i] A[mid] for loguy = i hi

A[hi] = A[mid] */

/* We've finished the partition, now we want to sort the subarrays

[lo, higuy] and [loguy, hi].

We do the smaller one first to minimize stack usage.

We only sort arrays of length 2 or more.*/

if ( higuy - lo = hi - loguy ) {

if (lo higuy) {

lostk[stkptr] = lo;

histk[stkptr] = higuy;

++stkptr;

} /* save big recursion for later */

if (loguy hi) {

lo = loguy;

goto recurse; /* do small recursion */

}

}

else {

if (loguy hi) {

lostk[stkptr] = loguy;

histk[stkptr] = hi;

++stkptr; /* save big recursion for later */

}

if (lo higuy) {

hi = higuy;

goto recurse; /* do small recursion */

}

}

}

/* We have sorted the array, except for any pending sorts on the stack.

Check if there are any, and do them. */

--stkptr;

if (stkptr = 0) {

lo = lostk[stkptr];

hi = histk[stkptr];

goto recurse; /* pop subarray from stack */

}

else

return; /* all subarrays done */

}

C语言库函数源代码在哪里有看

有安装vs2008或2010吗，在安装目录下面的VC/src中自带有源代码。比如我的就在

D:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src中。没有的话发给你

如何看c语言标准库函数的源代码?

1、首先标准只是规定了这些函数的接口和具体的运行效率的要求，这些函数具体是怎么写得要看各个编译器的实现和平台。

2、例如使用的编译器是visual studio，微软提供了一部分C运行时(CRT)的源码，里面会有memcpy，strcpy之类的函数的实现，在visual studio 2005下的路径是C:\Program Files\Microsoft Visual Studio 8\VC\crt\src。

C语言

C语言是一门通用计算机编程语言，应用广泛。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。

本文题目：C语言库函数源码在线阅读 c语言标准库函数源码
当前路径：http://scyanting.com/article/dosdiss.html