甜橘子，专注成都网站制作网站设计与营销型网站建设与优化
QQ :532337155
电话：028-86922220
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 */
}
有安装vs2008或2010吗，在安装目录下面的VC/src中自带有源代码。比如我的就在
D:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src中。没有的话发给你
1、首先标准只是规定了这些函数的接口和具体的运行效率的要求，这些函数具体是怎么写得要看各个编译器的实现和平台。
2、例如使用的编译器是visual studio，微软提供了一部分C运行时(CRT)的源码，里面会有memcpy，strcpy之类的函数的实现，在visual studio 2005下的路径是C:\Program Files\Microsoft Visual Studio 8\VC\crt\src。
C语言
C语言是一门通用计算机编程语言，应用广泛。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。