Linux C 第九章 数据结构函数

第九章 数据结构函数
#include <stdlib.h>
#include <search.h>

bsearch : void *bsearch(const void *key, const void *base, size_t nmemb, 
                        size_t size, int(*compar)(const void*, const void*)); 
        //二元搜索
        bsearch()利用二元搜索从排序好的数组中查找数据。参数key指向欲查找的关键数据，
        参数base指向要被搜索的数组开头地址，参数nmemb代表数组中的元素数量，每一元素
        的大小则由参数size决定，最后一项参数compar为函数指针，这个函数用来判断两个元
        素之间的大小关系，若传给compar的第一个参数所指元素数据大于第二个参数所指的元
        素数据则必须回传大于0的值，两个元素数据相等则回传0；
        找到关键数据则返回找到的地址，如果在数组中找不到关键数据则返回NULL;
        #include <stdio.h>
        #include <stdlib.h>

        #define NMEMB 5
        #define SIZE 10
        int compar(const void *a, const void *b)
        {
            return (strcmp((char*)a, (char*)b));
        }

        main(void)
        {
            char data[50][SIZE] = {"linux","freebsd", "solaris", "sunos", "windows"};
            char key[80], *base, *offset;
            int i, nmemb = NMEMB, size = SIZE;
            while(1) {
                printf(">");
                fgets(key, sizeof(key), stdin);
                key[strlen(key) - 1] = '\0';
                if (!strcmp(key, ".exit"))break;
                if (!strcmp(key, ".list")) {
                    for (i = 0; i < nmemb; i++) {
                        printf("%s\n", data[i]);
                        continue;
                    }
                    base = data[0];
                    qsort(base, nmemb, size, compar);
                    offset = (char *)bsearch(key, base, nmemb, size, compar);
                    if (offset == NULL) {
                        printf("%s not found!\n", key);
                        strcpy(data[nmemb++], key);
                        printf("Add %s to data array\n", key);
                    }else{
                        printf("found: %s \n", offset);
                    }

                }
            }
        }

hcreate :int hcreate(unsigned nel);
    用来建立哈希表，参数nel为哈希表最大量的估计值；
    如果无法成功建立哈希表则返回NULL;

hdestory :void hdestory();
    用来销毁目前使用的哈希表，如果想建立新的哈希表则必须先利用此函数销毁目前的哈希表；

hsearch :ENTRY *hsearch(ENTRY item, ACTION action);
    hsearch()会从目前使用的哈希表中查找参数item结构中的key关键数据，如果参数action为FIND,
    则找到数据后就会将关键数据的地址返回，找不到则返回NULL。如果参数action为ENTER,找不到
    关键数据时会主动把该数据加入哈希表中.
    结构ENTRY定义如下：
    typedef struct entry{
        char *key;
        char *data;
    } ENTRY;

    key字符串指针，指向以NULL为结尾的字符串，用来搜索使用。data指针则指向与key相关的数据地址；
    找到关键数据则返回找到的地址，如果在哈希表中找不到关键数据则返回NULL；

insque :void insque(struct qelem *elem, struct qelem *prev);
    加入一项目至队列中
    insque() 和 remque()用来操作一双向链接串连队列；
    qelem结构定义如下：
    struct qelem{
        struct qelem *q_forw;
        struct qelem *q_back;
        char q_data[1];
    };
    insque()将参数elem所指的项目插到队列中参数prev所指的项目后面；
    此参数prev不可为空(NULL)；

lfind : void *lfind(const void *key, const void *base, size_t *nmemb, size_t size,
                    int (*compar)(const void *, const void *));
        线性搜索；
        lfind()利用线性搜索在数组中从头到尾一项项查找数据，参数key指向欲查找的关键数据，
        参数base指向要被搜索的数组开头地址，参数nmemb代表数组中的元素数量，每一元素的大
        小则由参数size决定，最后一项参数compar为函数指针，这个函数用来判断两个元素是否相同，
        若传给compar的第一个参数所指元素数据和第二个参数所指的元素数据相同则返回0值，两个元
        素不相同则返回非0值，lfind()与lsearch()不同点在于，当找不到关键数据时lfind()仅会返回NULL,
        而不会主动把该数据加入数组尾端；
        找到关键数据则返回找到的地址，如果在数组中找不到关键数据则返回NULL;

lsearch :void *lsearch(const void *key, const void *base, size_t nmemb, size_t size,
                int(*compar)(const void *, const void *));
        线性搜索；
        lsearch()利用线性搜索在数组中从头到尾一项项查找数据，参数key指向欲查找的关键数据，
        参数base指向要被搜索的数组开头地址，参数nmemb代表数组中的元素数量，每一元素的大
        小则由参数size决定，最后一项参数compar为函数指针，这个函数用来判断两个元素是否相同，
        若传给compar的第一个参数所指元素数据和第二个参数所指的元素数据相同则返回0值，两个元
        素不相同则返回非0值，如果lsearch()找不到关键数据时会主动把该数据加入数组里；
        找到关键数据则返回找到的地址，如果在数组中找不到关键数据则将该数据加入数组，再返回
        数组后的地址；
        #include <stdio.h>
        #include <stdlib.h>
        #define NMEMB 50
        #define SIZE 10

        int compar(const void *a, const void *b)
        {
            return (strcmp((char *)a, (char *)b)); // 利用strcmp()比较字符串
        }
        main()
        {
            char data[NMEMB][SIZE] = {"linux", "android", "java", "windows"};
            char key[80], *base, *offset;
            int i, nmemb = NMEMB, size = SIZE;
            for (i=0; i < 5; i++){
                fgets(key, sizeof(key), stdin); /* 输入关键字 */
                key[strlen(key)-1] = '\0'; /* 去掉'\n' 字符 */
                base = data[0]; /* 设置从data数组开头搜索 */
                offset = (char *)lfind(key, base, &nmemb, size, compar);
                if (offset == NULL) {
                    printf("%s not found!\n", key);
                    offset = (char *)lsearch(key, base, &nmemb, size, compar);
                    printf("Add %s to data array\n", offset);
                } else {
                    printf("found :%s \n", offset);
                }
            }
        }

qsort :void qsort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));
        利用快速排序法排列数组；
        参数base批向欲排序的数组开头地址，参数nmemb代表数组中的元素量，每一元素的大小则由参数size决定，
        最后一项参数compar为函数指针，这个函数用来判断两个元素间的大小关系，若传给compar的第一个参数所
        指向的元素数据大于第二个参数所指向的数据则必须回传大于零的值，两个元素数据相等则回传0；
        #include <stdlib.h>
        #define nmemb 7
        int compar(const void *a, const void *b)
        {
            int *aa = (int *)a, *bb = (int *)b;
            if (*aa > *bb) return 1;
            if (*aa == *bb) return 0;
            if (*aa < *bb) return -1;
        }

        main()
        {
            int base[nmemb] = {4, 15, 65, 45, 153, 88, 99};
            int i;
            for (i=0; i<nmemb; i++)
            {
                printf("%d ", base[i]);
            }
            printf("\n");
            qsort(base, nmemb, sizeof(int), compar);
            for(i=0; i<nmemb; i++) {
                printf("%d ", base[i]);
            }
            printf("\n");

        }

remque :void remque(struct qelem *elem);
    从队列中删除一项目；
    insque()和remque()用来操作一双向链接串连队列；
    remque()用来将参数elem所指的项目从队列中删除；
    qelem结构定义如下：
    struct qelem {
        struct qelem *q_forw;
        struct qelem *q_back;
        char q_data[1];
    };

tdelete: void *tdelete(const void *key, const void **rootp, int(*compar)(const void *, const void*));
    从二叉树中删除数据；
    tdelete()用来将参数key指向的关键数据，从参数rootp指向的二叉树内移出。参数compar为一函数指针，此函数
    用来判断两个元素间的大小关系，若传给compar的第一个参数所指向的元素数据大于第二个参数所指向的元素数据
    则必须回传大于零的值，两个元素相等则回传0；
    找到关键数据予以删除，并将其父节点指针返回。如果在二叉树中找不到关键数据，则返回NULL;

tfind : void *tfind(const void *key, const void **rootp, int(*compar)(const void *, const void *));
    搜索二叉树；
    tfind()和tsearch()非常类似。参数key指向欲查找的关键数据，参数rootp指向二叉树根节点地址，与tsearch()不同的是，
    如果在二叉树中找不到关键数据，则不会加入此数据至二叉树内。参数compar为一函数指针，此函数用来判断两个元素间
    的大小关系，若传给compar的第一个参数所指向的元素数据大于第二个参数所指向的元素数据则必须回传大于零的值，
    两个元素相等则回传0；
    找到关键数据则返回找到的地址，如查在二叉树中找不到关键数据，则返回NULL;

tsearch :void *tsearch(const void *key, const void **rootp, int(*compar)(const void *, const void *));
    tsearch()用来建立或搜索二叉树，参数key指向欲查找的关键数据，参数rootp指向二叉树根节点地址，如果此参数为NULL,
    就会建立新的二叉树。参数compar为一函数指针，此函数用来判断两个元素间的大小关系，若传给compar的第一个参数所指
    向的元素数据大于第二个参数所指向的元素数据则必须回传大于零的值，两个元素相等则回传0；
    找到关键数据则返回找到的地址，如果在二叉树中找不到关键数据，则会将此数据加入到二叉树中，然后将新加入的地址返回。

twalk :void twalk(const void *root, void(*action)(const void *nodep, const VISIT which, const int depth));
    走访二叉树；
    twalk()用来走访已建立好的二叉树。参数root指向二叉树的根节点地址，参数action为一函数指针，这个函数为处理函数，
    每次进入一个节点都会调用此函数。传给action函数的第一个参数nodep为目前节点的指针，第二个参数which为一整数值，
    代表四种走访方式：
    1.preorder:先走访节点，其次走访左节点，最后走访右节点；
    2.postorder:先走访左节点，其次走访节点，最后走访右节点；
    3.endorder:先走访左节点，其次走访右节点，最后走访节点；
    4.leaf:节点为唯一被走访的，没有其他子节点；
    第三个参数代表目前节点的深度，如果是根节点则为0；