qsort 微软内部实现

void __fileDECL qsort (
					   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 */

recurse:

	size = (hi - lo) / width + 1;        /* number of el's to sort */
	if (size <= CUTOFF) {
		__SHORTSORT(lo, hi, width, comp, context);
	}
	else {

		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);
		}
		loguy = lo;
		higuy = hi;
		for (;;) {
			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);
			}
			do  {
				higuy -= width;
			} while (higuy > mid && __COMPARE(context, higuy, mid) > 0);
			if (higuy < loguy)
				break;
			swap(loguy, higuy, width);

			if (mid == higuy)
				mid = loguy;
		}
		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);
		}
		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 */
			}
		}
	}
	--stkptr;
	if (stkptr >= 0) {
		lo = lostk[stkptr];
		hi = histk[stkptr];
		goto recurse;           /* pop subarray from stack */
	}
	else
		return;                 /* all subarrays done */
}