VBGood网站全文搜索 Google

搜索VBGood全站网页(全文搜索)

VB爱好者乐园(VBGood)

 找回密码
 立即注册
搜索
12
返回列表 发新帖
楼主: VBProFan

[ZT]VC中的qsort源代码,值得学习

[复制链接]
发表于 2009-12-28 10:33:55 | 显示全部楼层
作者像是以前搞FORTRAN的,注释行喜欢用*开头。

注释的很好很详细,值得学习。
回复 支持 反对

使用道具 举报

发表于 2010-4-4 16:18:04 | 显示全部楼层
啊!不会吧?这些库函数的源码不是属于商业机密吗?
毕竟 VC 的开发小组还是付出了一些劳动的,不是简单地把地球上满天飞的C代码直接抄来的。。。

ps1:第一次粘贴时没有用 [code] 括起来,导致  全部丢失,刚才用 Editplus 把“A ”替换为“A ”,不知道有没有替换错的地方,想直接用的朋友小心了;
ps2:这个函数的第四个参数让我见识到了 C 语言的恐怖之处,这是 BASIC 语言远远比不上的。
VBProFan 发表于 2009-12-14 17:57


?大的函?指?
回复 支持 反对

使用道具 举报

头像被屏蔽
发表于 2010-4-6 17:35:30 | 显示全部楼层
提示: 作者被禁止或删除 内容自动屏蔽
回复 支持 反对

使用道具 举报

发表于 2010-4-12 23:39:19 | 显示全部楼层
回复 支持 反对

使用道具 举报

发表于 2010-4-12 23:40:22 | 显示全部楼层
咦,我发现VC6和VC2005的qsort源代码不一样,有小的改动……
回复 支持 反对

使用道具 举报

发表于 2010-5-25 19:44:55 | 显示全部楼层
算法偶不太懂,偶不喜欢重复造轮子,所以偶用STL……
回复 支持 反对

使用道具 举报

发表于 2010-6-20 22:28:16 | 显示全部楼层
1# VBProFan
FreeBSD 版本

  1. /*-
  2. * Copyright (c) 1992, 1993
  3. *        The Regents of the University of California.  All rights reserved.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions
  7. * are met:
  8. * 1. Redistributions of source code must retain the above copyright
  9. *    notice, this list of conditions and the following disclaimer.
  10. * 2. Redistributions in binary form must reproduce the above copyright
  11. *    notice, this list of conditions and the following disclaimer in the
  12. *    documentation and/or other materials provided with the distribution.
  13. * 3. All advertising materials mentioning features or use of this software
  14. *    must display the following acknowledgement:
  15. *        This product includes software developed by the University of
  16. *        California, Berkeley and its contributors.
  17. * 4. Neither the name of the University nor the names of its contributors
  18. *    may be used to endorse or promote products derived from this software
  19. *    without specific prior written permission.
  20. *
  21. * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22. * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24. * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27. * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30. * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31. * SUCH DAMAGE.
  32. *
  33. * $FreeBSD: src/sys/libkern/qsort.c,v 1.10 1999/08/28 00:46:35 peter Exp $
  34. */

  35. #include <sys/libkern.h>

  36. typedef int                 cmp_t __P((const void *, const void *));
  37. static __inline char        *med3 __P((char *, char *, char *, cmp_t *));
  38. static __inline void         swapfunc __P((char *, char *, int, int));

  39. #define min(a, b)        (a) < (b) ? a : b

  40. /*
  41. * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function".
  42. */
  43. #define swapcode(TYPE, parmi, parmj, n) {                 \
  44.         long i = (n) / sizeof (TYPE);                         \
  45.         register TYPE *pi = (TYPE *) (parmi);                 \
  46.         register TYPE *pj = (TYPE *) (parmj);                 \
  47.         do {                                                 \
  48.                 register TYPE        t = *pi;                \
  49.                 *pi++ = *pj;                                \
  50.                 *pj++ = t;                                \
  51.         } while (--i > 0);                                \
  52. }

  53. #define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \
  54.         es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1;

  55. static __inline void
  56. swapfunc(a, b, n, swaptype)
  57.         char *a, *b;
  58.         int n, swaptype;
  59. {
  60.         if(swaptype <= 1)
  61.                 swapcode(long, a, b, n)
  62.         else
  63.                 swapcode(char, a, b, n)
  64. }

  65. #define swap(a, b)                                        \
  66.         if (swaptype == 0) {                                \
  67.                 long t = *(long *)(a);                        \
  68.                 *(long *)(a) = *(long *)(b);                \
  69.                 *(long *)(b) = t;                        \
  70.         } else                                                \
  71.                 swapfunc(a, b, es, swaptype)

  72. #define vecswap(a, b, n)         if ((n) > 0) swapfunc(a, b, n, swaptype)

  73. static __inline char *
  74. med3(a, b, c, cmp)
  75.         char *a, *b, *c;
  76.         cmp_t *cmp;
  77. {
  78.         return cmp(a, b) < 0 ?
  79.                (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a ))
  80.               :(cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c ));
  81. }

  82. void
  83. qsort(a, n, es, cmp)
  84.         void *a;
  85.         size_t n, es;
  86.         cmp_t *cmp;
  87. {
  88.         char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
  89.         int d, r, swaptype, swap_cnt;

  90. loop:        SWAPINIT(a, es);
  91.         swap_cnt = 0;
  92.         if (n < 7) {
  93.                 for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es)
  94.                         for (pl = pm; pl > (char *)a && cmp(pl - es, pl) > 0;
  95.                              pl -= es)
  96.                                 swap(pl, pl - es);
  97.                 return;
  98.         }
  99.         pm = (char *)a + (n / 2) * es;
  100.         if (n > 7) {
  101.                 pl = a;
  102.                 pn = (char *)a + (n - 1) * es;
  103.                 if (n > 40) {
  104.                         d = (n / 8) * es;
  105.                         pl = med3(pl, pl + d, pl + 2 * d, cmp);
  106.                         pm = med3(pm - d, pm, pm + d, cmp);
  107.                         pn = med3(pn - 2 * d, pn - d, pn, cmp);
  108.                 }
  109.                 pm = med3(pl, pm, pn, cmp);
  110.         }
  111.         swap(a, pm);
  112.         pa = pb = (char *)a + es;

  113.         pc = pd = (char *)a + (n - 1) * es;
  114.         for (;;) {
  115.                 while (pb <= pc && (r = cmp(pb, a)) <= 0) {
  116.                         if (r == 0) {
  117.                                 swap_cnt = 1;
  118.                                 swap(pa, pb);
  119.                                 pa += es;
  120.                         }
  121.                         pb += es;
  122.                 }
  123.                 while (pb <= pc && (r = cmp(pc, a)) >= 0) {
  124.                         if (r == 0) {
  125.                                 swap_cnt = 1;
  126.                                 swap(pc, pd);
  127.                                 pd -= es;
  128.                         }
  129.                         pc -= es;
  130.                 }
  131.                 if (pb > pc)
  132.                         break;
  133.                 swap(pb, pc);
  134.                 swap_cnt = 1;
  135.                 pb += es;
  136.                 pc -= es;
  137.         }
  138.         if (swap_cnt == 0) {  /* Switch to insertion sort */
  139.                 for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es)
  140.                         for (pl = pm; pl > (char *)a && cmp(pl - es, pl) > 0;
  141.                              pl -= es)
  142.                                 swap(pl, pl - es);
  143.                 return;
  144.         }

  145.         pn = (char *)a + n * es;
  146.         r = min(pa - (char *)a, pb - pa);
  147.         vecswap(a, pb - r, r);
  148.         r = min(pd - pc, pn - pd - es);
  149.         vecswap(pb, pn - r, r);
  150.         if ((r = pb - pa) > es)
  151.                 qsort(a, r / es, es, cmp);
  152.         if ((r = pd - pc) > es) {
  153.                 /* Iterate rather than recurse to save stack space */
  154.                 a = pn - r;
  155.                 n = r / es;
  156.                 goto loop;
  157.         }
  158. /*                qsort(pn - r, r / es, es, cmp);*/
  159. }
复制代码
回复 支持 反对

使用道具 举报

发表于 2010-6-20 23:23:37 | 显示全部楼层
17# redraiment

好像短一点……GCC用的是什么?
回复 支持 反对

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

文字版|手机版|小黑屋|VBGood  

GMT+8, 2023-3-22 04:25

VB爱好者乐园(VBGood)
快速回复 返回顶部 返回列表