【程序设计实践】第2章 算法和数据结构

第2章 算法和数据结构
即使是很复杂的程序，也是由简单的数组、表、散列表等简单东西堆砌起来的。

检索

顺序检索，二分检索

排序

快速排序

库

C函数库中的qsort，调用时必须提供一个比较函数。ANSI C的二分检索函数：bsearch，它也要求一个指向比较函数的指针。标准C++库中有个名为sort的类属算法。
某一种快速排序：
/* quicksort: sort v[0]..v[n-1] into increasing order */
void quicksort(int v[], int n)
{
int i, last;
if (n <= 1) /* nothing to do */
       return;
swap(v, 0, rand() % n); /* move pivot elem to v[0] */
last = 0;
for (i = 1; i < n; i++) /* partition */
       if (v[i] < v[0])
              swap(v, ++last, i);
swap(v, 0, last); /* restore pivot */
quicksort(v, last); /* recursively sort */
quicksort(v+last+1, n-last-1); /* each part */
}
/* swap: interchange v[i] and v[j] */
void swap(int v[], int i, int j)
{
       int temp;
       temp = v[i];
       v[i] = v[j];
       v[j] = temp;
}
排序算法花费的时间正比于nlogn。

可增长数组

定义一个可增长数组，新元素被加到有关数组的最后。在必要时将自动增大以提供新的空间。删除名字需要一点诀窍，如果元素顺序不重要，最简单的方法就是把位于数组的最后元素复制到这里。
typedef struct Nameval Nameval;
struct Nameval {
       char        *name;
       int          value;
};
struct Nvtab {
       int          nval;              /* current number of values */
       int          max;              /* allocated number of values */
       Nameval *nameval;      /* array of name-value pairs */
};
enum { NVINIT = 1, NVGROW = 2 };
/* addname: add new name and value to nvtab */
int addname(Nameval newname)
{
       Nameval *nvp;
       if (nvtab.nameval == NULL) {    /* first time */
              nvtab.nameval = (Nameval *) malloc(NVINIT * sizeof(Nameval));
              if (nvtab.nameval == NULL)
                     return -1;
              nvtab.max = NVINIT;
              nvtab.nval = 0;
       } else if (nvtab.nval >= nvtab.max) {       /* grow */
              nvp = (Nameval *) realloc(nvtab.nameval,
                            (NVGROW*nvtab.max) * sizeof(Nameval));
              if (nvp == NULL)
                     return -1;
              nvtab.max *= NVGROW;
              nvtab.nameval = nvp;
       }
       nvtab.nameval[nvtab.nval] = newname;
       return nvtab.nval++;
}
/* delname: remove first matching nameval from nvtab */
int delname(char *name)
{
       int i;
       for (i = 0; i < nvtab.nval; i++)
              if (strcmp(nvtab.nameval[i].name, name) == 0) {
                     memmove(nvtab.nameval+i, nvtab.nameval+i+1,
                                   (nvtab.nval-(i+1)) * sizeof(Nameval));
                     nvtab.nval--;
                     return 1;
              }
}
在ANSI C的标准库里定义了两个相关的函数：memcpy的速度快，但是如果源位置和目标位置重叠，它有可能覆盖掉存储区中的某些部分；memmove函数的速度可能慢些，但总能保证复制的正确完成。

表

单链表，构造表的最简单的办法就是把每个元素加在最前面。
我们无法在编译时初始化一个非空的表，这点也与数组不同。表应该完全是动态构造起来的。
二分检索完全不能适用于表。
/* apply: execute fn for each element of listp */
void apply(Nameval *listp, void (*fn)(Nameval*, void*), void *arg)
{
       for ( ; listp != NULL; listp = listp->next)
              (*fn)(listp, arg);    /* call the function */
}
要使用apply，例如打印一个表的元素，我们可以写一个简单的函数，其参数包括一个格式描述串：
/* printnv: print name and value using format in arg */
void printnv(Nameval *p, void *arg)
{
       char *fmt;
       fmt = (char *) arg;
       printf(fmt, p->name, p->value);
}
它的调用形式是：
apply(nvlist, printnv, “%s: %x"n”);
要销毁一个表就必须特别小心：
/* freeall: free all elements of listp */
void freeall(Nameval *listp)
{
       Nameval *next;
       for ( ; listp != NULL; listp = next) {
              next = listp->next;
              /* assumes name is freed elsewhere */
              free(listp);
       }
}

树

二叉树，树的构造，树的遍历。

散列表

常见做法是为每个散列值(或称桶)关联一个项的链表，即数组的每个元素是个链表，链接起具有该散列值的所有数据项。散列函数hash应该计算出什么东西。这个函数必须是确定性的，应该能算得很快，应该把数据均匀地散布到数组里。对于字符串，最常见的散列算法之一就是：逐个把字节加到已经构造的部分散列值的一个倍数上。乘法能把新字节在已有的值中散开来。这样，最后结果将是所有输入字节的一种彻底混合。根据经验，在对ASCII串的散列函数中，选择31和37作为乘数是很好的。

小结

选择算法有几个步骤。首先，应参考所有可能的算法和数据结构，考虑程序将要处理的数据大概有多少。如果被处理数据的量不大，那么就选择最简单的技术。如果数据可能增长，请删掉那些不能对付大数据集合的东西。然后，如果有库或者语言本身的特征可以使用，就应该使用。如果没有，那么就写或者借用一个短的、简单的和容易理解的实现。如果实际测试说明它太慢，那么就需要改用某种更高级的技术。