复习要点

第一章 绪论

数据结构：
广义定义：数据结构是一门研究非数值计算的程序设计问题中计算机的操作对像以及它们之间的关系和操作等的学科。
狭义定义：数据结构是相互之间存在一种或多种特定关系的数据元素的集合。

数据元素：
数据元素是数据的基本单位，在计算机中通常作为一个整体进行考虑和处理。有时一个数据元素可以由若干个数据项组成，数据项是数据元素不可分割的最小单位。

数据类型：
按“值”的不同特性可分为：
原子类型：基本类型（整型，实型，字符型，枚举型），指针类型和空类型
结构类型：值由若干成分按某种结构组成
抽象数据类型（ADT）：原子类型，固定聚合类型，可变聚合类型

逻辑结构（线性、非线性）
复习提要（20级） - 图1

存储结构（顺序、链式）
顺序存储：存储的物理位置相邻。（p.s. 物理位置即信息在计算机中的位置。）
链接存储：存储的物理位置未必相邻，通过记录相邻元素的物理位置来找到相邻元素。
索引存储
散列存储

时间复杂度（大O表示法）、语句执行频度计算
复习提要（20级） - 图2

  • 时间复杂度计算（单个循环体）
    • 直接关注循环体的执行次数，设为k
  • 时间复杂度计算（多个循环体）
    • 两个运算规则：乘法规则，加法规则。

第二章 线性表

线性表的定义及特点：
定义：线性表是具有相同数据类型的n（n≥0）个数据元素的有限序列
特点：线性表中第一个元素称为表头元素；最后一个元素称为表尾元素。除第一个元素外，每个元素有且仅有一个直接前驱。除最后一个元素外，每个元素有且仅有一个直接后继。
顺序存储：查找快，增删慢 链表：查找慢，增删快

线性表的顺序存储及基本操作（插入、删除等）

  1. /*
  2.  * 顺序表结构
  3.  *
  4.  * 注：elem在使用前需要先为其分配内存，且元素从elem[0]处开始存储
  5.  */
  6. typedef struct {
  7.     ElemType* elem;     // 顺序表存储空间的基址（指向顺序表所占内存的起始位置）
  8.     int length;   // 当前顺序表长度（包含多少元素）
  9.     int listsize; // 当前分配的存储容量（可以存储多少元素）
  10. } SqList;
  12. /*
  13.  * ████████ 算法2.4 ████████
  14.  *
  15.  * 插入
  16.  *
  17.  * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。
  18.  *
  19.  *【备注】
  20.  * 教材中i的含义是元素位置，从1开始计数
  21.  */
  22. Status ListInsert(SqList* L, int i, ElemType e) {
  23.     ElemType* newbase;
  24.     ElemType* p, * q;
  26.     // 确保顺序表结构存在
  27.     if(L == NULL || (*L).elem == NULL) {
  28.         return ERROR;
  29.     }
  31.     // i值越界
  32.     if(i < 1 || i > (*L).length + 1) {
  33.         return ERROR;
  34.     }
  36.     // 若存储空间已满，则增加新空间
  37.     if((*L).length >= (*L).listsize) {
  38.         // 基于现有空间扩容
  39.         newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType));
  40.         if(newbase == NULL) {
  41.             // 存储内存失败
  42.             exit(OVERFLOW);
  43.         }
  45.         // 新基址
  46.         (*L).elem = newbase;
  47.         // 存的存储空间
  48.         (*L).listsize += LISTINCREMENT;
  49.     }
  51.     // q为插入位置
  52.     q = &(*L).elem[i - 1];
  54.     // 1.右移元素，腾出位置
  55.     for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) {
  56.         *(p + 1) = *p;
  57.     }
  59.     // 2.插入e
  60.     *q = e;
  62.     // 3.表长增1
  63.     (*L).length++;
  65.     return OK;
  66. }
  68. /*
  69.  * ████████ 算法2.5 ████████
  70.  *
  71.  * 删除
  72.  *
  73.  * 删除顺序表第i个位置上的元素，并将被删除元素存储到e中。
  74.  * 删除成功则返回OK，否则返回ERROR。
  75.  *
  76.  *【备注】
  77.  * 教材中i的含义是元素位置，从1开始计数
  78.  */
  79. Status ListDelete(SqList* L, int i, ElemType* e) {
  80.     ElemType* p, * q;
  82.     // 确保顺序表结构存在
  83.     if(L == NULL || (*L).elem == NULL) {
  84.         return ERROR;
  85.     }
  87.     // i值越界
  88.     if(i < 1 || i > (*L).length) {
  89.         return ERROR;
  90.     }
  92.     // p为被删除元素的位置
  93.     p = &(*L).elem[i - 1];
  95.     // 1.获取被删除元素
  96.     *e = *p;
  98.     // 表尾元素位置
  99.     q = (*L).elem + (*L).length - 1;
  101.     // 2.左移元素，被删除元素的位置上会有新元素进来
  102.     for(++p; p <= q; ++p) {
  103.         *(p - 1) = *p;
  104.     }
  106.     // 3.表长减1
  107.     (*L).length--;
  109.     return OK;
  110. }
  • 链表的基本操作及应用（插入、删除、查找等） ```c /
    • 单链表结构 *
    • 注：这里的单链表存在头结点 / typedef struct LNode { ElemType data; // 数据结点 struct LNode next; // 指向下一个结点的指针 } LNode;

/*

  • ████████ 算法2.9 ████████ *
  • 插入 *
  • 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 【备注】

  • 教材中i的含义是元素位置，从1开始计数 */ Status ListInsert(LinkList L, int i, ElemType e) { LinkList p, s; int j;

    // 确保链表存 if(L == NULL) {

    1.  return ERROR;

    }

    p = L; j = 0;

    // 寻找第i-1个结点，且保证该结点本身不为NULL while(p != NULL && j < i - 1) {

    1.  p = p->next;
    2.  ++j;

    }

    // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 if(p == NULL || j > i - 1) {

    1.  return ERROR;

    }

    // 生成新结点 s = (LinkList) malloc(sizeof(LNode)); if(s == NULL) {

    1.  exit(OVERFLOW);

    } s->data = e; s->next = p->next; p->next = s;

    return OK; }

/*

  • ████████ 算法2.10 ████████ *
  • 删除 *
  • 删除链表第i个位置上的元素，并将被删除元素存储到e中。
  • 删除成功则返回OK，否则返回ERROR。 【备注】

  • 教材中i的含义是元素位置，从1开始计数 / Status ListDelete(LinkList L, int i, ElemType e) { LinkList p, q; int j;

    // 确保链表存在且不为空表 if(L == NULL || L->next == NULL) {

    1.  return ERROR;

    }

    p = L; j = 0;

    // 寻找第i-1个结点，且保证该结点的后继不为NULL while(p->next != NULL && j < i - 1) {

    1.  p = p->next;
    2.  ++j;

    }

    // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 if(p->next == NULL || j > i - 1) {

    1.  return ERROR;

    }

    // 删除第i个结点 q = p->next; p->next = q->next; *e = q->data; free(q);

    return OK; }

/*

  • 查找 *
  • 返回链表中首个与e满足Compare关系的元素位序。
  • 如果不存在这样的元素，则返回0。 【备注】

  • 元素e是Compare函数第二个形参 */ int LocateElem(LinkList L, ElemType e, Status(Compare)(ElemType, ElemType)) { int i; LinkList p;

    // 确保链表存在且不为空表 if(L == NULL || L->next == NULL) {

    1.  return 0;

    }

    i = 1; // i的初值为第1个元素的位序 p = L->next; // p的初值为第1个元素的指针

    while(p != NULL && !Compare(p->data, e)) {

    1.  i++;
    2.  p = p->next;

    }

    if(p != NULL) {

    1.  return i;

    } else {

    1.  return 0;

    } }

  1. ```c
  2. /*
  3.  * 静态链表结构
  4.  *
  5.  * 注：静态链表依托于一个数组，该数组包含了已占用空间和空闲空间
  6.  */
  7. typedef struct SLinkNode {
  8.     ElemType data;
  9.     int cur;            // cur是游标，做指针用，用来链接下一个结点（区别于数组下标）
  10. } SLinkList[MAXSIZE];   // 链表空间类型
  12. /*
  13.  * 插入
  14.  *
  15.  * 向静态链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。
  16.  *
  17.  *【备注】
  18.  * 教材中i的含义是元素位置，从1开始计数
  19.  */
  20. Status ListInsert(SLinkList space, int S, int i, ElemType e) {
  21.     int p, s;
  22.     int j;
  24.     // 确保静态链表存在
  25.     if(S == 0) {
  26.         return ERROR;
  27.     }
  29.     p = S;
  30.     j = 0;
  32.     // 寻找第i-1个结点，且保证该结点本身存在
  33.     while(p != 0 && j < i - 1) {
  34.         p = space[p].cur;
  35.         ++j;
  36.     }
  38.     // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点
  39.     if(p == 0 || j > i - 1) {
  40.         return ERROR;
  41.     }
  43.     // 生成新结点
  44.     s = Malloc(space);
  45.     space[s].data = e;
  46.     space[s].cur = space[p].cur;
  47.     space[p].cur = s;
  49.     return OK;
  50. }
  52. /*
  53.  * 删除
  54.  *
  55.  * 删除静态链表第i个位置上的元素，并将被删除元素存储到e中。
  56.  * 删除成功则返回OK，否则返回ERROR。
  57.  *
  58.  *【备注】
  59.  * 教材中i的含义是元素位置，从1开始计数
  60.  */
  61. Status ListDelete(SLinkList space, int S, int i, ElemType* e) {
  62.     int p, q;
  63.     int j;
  65.     // 确保静态链表存在
  66.     if(S == 0) {
  67.         return ERROR;
  68.     }
  70.     p = S;
  71.     j = 0;
  73.     // 寻找第i-1个结点，且保证该结点的后继存在
  74.     while(space[p].cur != 0 && j < i - 1) {
  75.         p = space[p].cur;
  76.         ++j;
  77.     }
  79.     // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点
  80.     if(space[p].cur == 0 || j > i - 1) {
  81.         return ERROR;
  82.     }
  84.     // 删除第i个结点
  85.     q = space[p].cur;
  86.     space[p].cur = space[q].cur;
  87.     *e = space[q].data;
  88.     Free(space, q);
  90.     return OK;
  91. }
  93. /*
  94.  * ████████ 算法2.13 ████████
  95.  *
  96.  * 查找
  97.  *
  98.  * 返回静态链表中首个与e满足Compare关系的元素位序。
  99.  * 如果不存在这样的元素，则返回0。
  100.  *
  101.  *【备注】
  102.  * 1.元素e是Compare函数第二个形参
  103.  * 2.这里的实现与教材上的算法2.13不相同，原因参见顶部的“注意”信息
  104.  */
  105. int LocateElem(SLinkList space, int S, ElemType e, Status(Compare)(ElemType, ElemType)) {
  106.     int i;
  107.     int p;
  109.     // 确保静态链表存在且不为空
  110.     if(S == 0 || space[S].cur == 0) {
  111.         return 0;
  112.     }
  114.     i = 1;              // i的初值为第1个元素的位序
  115.     p = space[S].cur;   // p的初值为第1个元素的索引
  117.     while(p != 0 && !Compare(space[p].data, e)) {
  118.         i++;
  119.         p = space[p].cur;
  120.     }
  122.     if(p != 0) {
  123.         return i;
  124.     } else {
  125.         return 0;
  126.     }
  127. }
  1. /*
  2.  * 双向循环链表结构
  3.  *
  4.  * 注：这里的双向循环链表存在头结点
  5.  */
  6. typedef struct DuLNode {
  7.     ElemType data;
  8.     struct DuLNode* prior;  // 前驱
  9.     struct DuLNode* next;   // 后继
  10. } DuLNode;
  12. /*
  13.  * ████████ 算法2.18 ████████
  14.  *
  15.  * 插入
  16.  *
  17.  * 向双向循环链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。
  18.  *
  19.  *【备注】
  20.  * 教材中i的含义是元素位置，从1开始计数
  21.  */
  22. Status ListInsert(DuLinkList L, int i, ElemType e) {
  23.     DuLinkList p, s;
  25.     // 确保双向循环链表存在（但可能为空表）
  26.     if(L == NULL) {
  27.         return ERROR;
  28.     }
  30.     // 查找第i个结点位置（引用）
  31.     if((p = GetElemP(L, i)) == NULL) {
  32.         return ERROR;
  33.     }
  35.     // 创建新结点
  36.     s = (DuLinkList) malloc(sizeof(DuLNode));
  37.     if(s == NULL) {
  38.         exit(OVERFLOW);
  39.     }
  40.     s->data = e;
  42.     // 将s插入到p的前面，称为第i个结点
  43.     s->prior = p->prior;
  44.     p->prior->next = s;
  45.     s->next = p;
  46.     p->prior = s;
  48.     return OK;
  49. }
  51. /*
  52.  * ████████ 算法2.19 ████████
  53.  *
  54.  * 删除
  55.  *
  56.  * 删除双向循环链表第i个位置上的元素，并将被删除元素存储到e中。
  57.  * 删除成功则返回OK，否则返回ERROR。
  58.  *
  59.  *【备注】
  60.  * 教材中i的含义是元素位置，从1开始计数
  61.  */
  62. Status ListDelete(DuLinkList L, int i, ElemType* e) {
  63.     DuLinkList p;
  65.     // 确保双向循环链表存在
  66.     if(L == NULL || L->next == L || L->prior == L) {
  67.         return ERROR;
  68.     }
  70.     // 查找第i个结点位置（引用）
  71.     if((p = GetElemP(L, i)) == NULL) {
  72.         return ERROR;
  73.     }
  75.     // 如果p==L，说明待删除元素是第len+1个元素，不合规
  76.     if(p == L) {
  77.         return ERROR;
  78.     }
  80.     *e = p->data;
  82.     // 移除p结点
  83.     p->prior->next = p->next;
  84.     p->next->prior = p->prior;
  86.     free(p);
  88.     return OK;
  89. }
  91. /*
  92.  * 查找
  93.  *
  94.  * 返回双向循环链表中首个与e满足Compare关系的元素位序。
  95.  * 如果不存在这样的元素，则返回0。
  96.  *
  97.  *【备注】
  98.  * 元素e是Compare函数第二个形参
  99.  */
  100. int LocateElem(DuLinkList L, ElemType e, Status(Compare)(ElemType, ElemType)) {
  101.     int i;
  102.     DuLinkList p;
  104.     // 确保双向循环链表存在
  105.     if(L == NULL || L->next == L || L->prior == L) {
  106.         return 0;
  107.     }
  109.     i = 1;          // i的初值为第1个元素的位序
  110.     p = L->next;    // p的初值为第1个元素的指针
  112.     while(p != L && !Compare(p->data, e)) {
  113.         i++;
  114.         p = p->next;
  115.     }
  117.     if(p != L) {
  118.         return i;
  119.     } else {
  120.         return 0;
  121.     }
  122. }

第三章 栈和队列

栈的定义及特点
栈（Stack）：只允许在一端进行插入或删除操作的线性表。
特点：1.栈是受限的线性表，所以自然具有线性关系。2.栈中元素后进去的必然先出来，即后进先出LIFO（Last In First Out）

栈的表示及实现（进栈、出栈、为空或满的判定条件）

  1. typedef struct
  2. {
  3.         SElemType data[MAXSIZE];
  4.         int top; /* 用于栈顶指针 */
  5. }SqStack;
  7. /* 插入元素e为新的栈顶元素 */
  8. Status Push(SqStack *S,SElemType e)
  9. {
  10.         if(S->top == MAXSIZE -1) /* 栈满 */
  11.         {
  12.                 return ERROR;
  13.         }
  14.         S->top++;                /* 栈顶指针增加一 */
  15.         S->data[S->top]=e;  /* 将新插入元素赋值给栈顶空间 */
  16.         return OK;
  17. }
  19. /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
  20. Status Pop(SqStack *S,SElemType *e)
  21. { 
  22.         if(S->top==-1)
  23.                 return ERROR;
  24.         *e=S->data[S->top];    /* 将要删除的栈顶元素赋值给e */
  25.         S->top--;                /* 栈顶指针减一 */
  26.         return OK;
  27. }

栈空：S->top==-1
栈满：S->top == MAXSIZE -1

  1. // 顺序栈元素结构
  2. typedef struct {
  3.     SElemType* base;               // 栈底指针
  4.     SElemType* top;                // 栈顶指针
  5.     int stacksize;                 // 当前已分配的存储空间，以元素为单位
  6. } SqStack;
  8. /*
  9.  * 入栈
  10.  *
  11.  * 将元素e压入到栈顶。
  12.  */
  13. Status Push(SqStack* S, SElemType e) {
  14.     if(S == NULL || (*S).base == NULL) {
  15.         return ERROR;
  16.     }
  18.     // 栈满时，追加存储空间
  19.     if((*S).top - (*S).base >= (*S).stacksize) {
  20.         (*S).base = (SElemType*) realloc((*S).base, ((*S).stacksize + STACKINCREMENT) * sizeof(SElemType));
  21.         if((*S).base == NULL) {
  22.             exit(OVERFLOW);     // 存储分配失败
  23.         }
  25.         (*S).top = (*S).base + (*S).stacksize;
  26.         (*S).stacksize += STACKINCREMENT;
  27.     }
  29.     // 进栈先赋值，栈顶指针再自增
  30.     *(S->top++) = e;
  32.     return OK;
  33. }
  35. /*
  36.  * 出栈
  37.  *
  38.  * 将栈顶元素弹出，并用e接收。
  39.  */
  40. Status Pop(SqStack* S, SElemType* e) {
  41.     if(S == NULL || (*S).base == NULL) {
  42.         return ERROR;
  43.     }
  45.     if((*S).top == (*S).base) {
  46.         return ERROR;
  47.     }
  49.     // 出栈栈顶指针先递减，再赋值
  50.     *e = *(--(*S).top);
  52.     return OK;
  53. }

栈空：(*S).top == (*S).base
栈满：(*S).top - (*S).base >= (*S).stacksize

队列的定义及特点
队列是只允许在一端进行插入，而在另一端进行删除的线性表
先进入队列的元素必然先离开队列，即先进先出（First In First Out）简称FIFO

循环队列（入列、出列、元素个数）

  1. // 队列元素结构
  2. typedef struct QNode {
  3.     QElemType data;
  4.     struct QNode* next;
  5. } QNode, * QueuePtr;
  7. // 队列结构
  8. typedef struct {
  9.     QueuePtr front;     // 队头指针
  10.     QueuePtr rear;      // 队尾指针
  11. } LinkQueue;            // 队列的链式存储表示
  13. /*
  14.  * 入队
  15.  *
  16.  * 将元素e添加到队列尾部。
  17.  */
  18. Status EnQueue(LinkQueue* Q, QElemType e) {
  19.     QueuePtr p;
  21.     if(Q == NULL || (*Q).front == NULL) {
  22.         return ERROR;
  23.     }
  25.     p = (QueuePtr) malloc(sizeof(QNode));
  26.     if(!p) {
  27.         exit(OVERFLOW);
  28.     }
  30.     p->data = e;
  31.     p->next = NULL;
  33.     (*Q).rear->next = p;
  34.     (*Q).rear = p;
  36.     return OK;
  37. }
  39. /*
  40.  * 出队
  41.  *
  42.  * 移除队列头部的元素，将其存储到e中。
  43.  */
  44. Status DeQueue(LinkQueue* Q, QElemType* e) {
  45.     QueuePtr p;
  47.     if(Q == NULL || (*Q).front == NULL || (*Q).front == (*Q).rear) {
  48.         return ERROR;
  49.     }
  51.     p = (*Q).front->next;
  52.     *e = p->data;
  54.     (*Q).front->next = p->next;
  55.     if((*Q).rear == p) {
  56.         (*Q).rear = (*Q).front;
  57.     }
  59.     free(p);
  61.     return OK;
  62. }
  64. /*
  65.  * 计数
  66.  *
  67.  * 返回链队包含的有效元素的数量。
  68.  */
  69. int QueueLength(LinkQueue Q) {
  70.     int count = 0;
  71.     QueuePtr p = Q.front;
  73.     while(p != Q.rear) {
  74.         count++;
  75.         p = p->next;
  76.     }
  78.     return count;
  79. }
  1. // 循环队列的顺序存储结构
  2. typedef struct {
  3.     QElemType* base;    // 动态分配存储空间
  4.     int front;          // 头指针，若队列不空，指向队头元素
  5.     int rear;           // 尾指针，若队列不空，指向队列尾元素的下一个位置
  6. } SqQueue;
  8. /*
  9.  * 入队
  10.  *
  11.  * 将元素e添加到队列尾部。
  12.  */
  13. Status EnQueue(SqQueue* Q, QElemType e) {
  14.     if(Q == NULL || (*Q).base == NULL) {
  15.         return ERROR;
  16.     }
  18.     // 队列满的标志（会浪费一个空间来区分队列空和队列满）
  19.     if(((*Q).rear + 1) % MAXQSIZE == (*Q).front) {
  20.         return ERROR;
  21.     }
  23.     // 入队
  24.     (*Q).base[(*Q).rear] = e;
  26.     // 尾指针前进
  27.     (*Q).rear = ((*Q).rear + 1) % MAXQSIZE;
  29.     return OK;
  30. }
  32. /*
  33.  * 出队
  34.  *
  35.  * 移除队列头部的元素，将其存储到e中。
  36.  */
  37. Status DeQueue(SqQueue* Q, QElemType* e) {
  38.     if(Q == NULL || (*Q).base == NULL) {
  39.         return ERROR;
  40.     }
  42.     // 队列空的标志
  43.     if((*Q).front == (*Q).rear) {
  44.         return ERROR;
  45.     }
  47.     // 出队
  48.     *e = (*Q).base[(*Q).front];
  50.     // 头指针前进
  51.     (*Q).front = ((*Q).front + 1) % MAXQSIZE;
  53.     return OK;
  54. }
  56. /*
  57.  * 计数
  58.  *
  59.  * 返回循环顺序队列包含的有效元素的数量。
  60.  */
  61. int QueueLength(SqQueue Q) {
  62.     if(Q.base == NULL) {
  63.         return 0;
  64.     }
  66.     // 队列长度
  67.     return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
  68. }

第四章 串

串的定义及基本操作
由零个或多个字符组成的有限序列。

  1. typedef unsigned char SString[MAXSTRLEN + 1];       // 0号单元存放串的长度
  3. /*
  4.  * ████████ 算法4.3 ████████
  5.  *
  6.  * 求子串
  7.  *
  8.  * 用Sub返回S[pos, pos+len-1]。
  9.  * 返回值指示是否截取成功。
  10.  *
  11.  *【注】
  12.  * 该操作属于最小操作子集
  13.  */
  14. Status SubString(SString Sub, SString S, int pos, int len) {
  15.     int i;
  17.     if(pos < 1 || pos > S[0] || len < 0 || pos + len - 1 > S[0]) {
  18.         return ERROR;
  19.     }
  21.     // 复制元素
  22.     for(i = 1; i <= len; i++) {
  23.         Sub[i] = S[pos + i - 1];
  24.     }
  26.     // 确定新长度
  27.     Sub[0] = len;
  29.     return OK;
  30. }
  32. /*
  33.  * ████████ 算法4.1 ████████
  34.  *
  35.  * 查找
  36.  *
  37.  * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
  38.  * 如果查找成功，返回匹配的位置。
  39.  *
  40.  *【注】
  41.  * 1.此实现需要依赖串的最小操作子集
  42.  * 2.该实现比较低效
  43.  */
  44. int Index_1(SString S, SString T, int pos) {
  45.     int i, n, m;       // 记录S和T的长度
  46.     SString sub;
  48.     /*
  49.      * 失败情形提前处理
  50.      * 这里与教材写法略微不同
  51.      */
  52.     if(pos < 1 || pos > S[0] || StrEmpty(T)) {
  53.         return 0;
  54.     }
  56.     n = StrLength(S);
  57.     m = StrLength(T);
  58.     i = pos;
  60.     // 保证长度不越界
  61.     while(i <= n - m + 1) {
  62.         // 获取S[i, i+m-1]
  63.         SubString(sub, S, i, m);
  65.         // 如果子串与模式串不匹配，则需要继续推进
  66.         if(StrCompare(sub, T) != 0) {
  67.             ++i;
  68.         } else {
  69.             return i;
  70.         }
  71.     }
  73.     return 0;
  74. }
  76. /*
  77.  * ████████ 算法4.5 ████████
  78.  *
  79.  * 查找
  80.  *
  81.  * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
  82.  * 如果查找成功，返回匹配的位置。
  83.  *
  84.  *【注】
  85.  * 1.此实现不依赖串的最小操作子集
  86.  * 2.该实现比较低效
  87.  */
  88. int Index_2(SString S, SString T, int pos) {
  89.     int i = pos;
  90.     int j = 1;
  92.     if(pos < 1 || pos > S[0] || StrEmpty(T)) {
  93.         return 0;
  94.     }
  96.     while(i <= S[0] && j <= T[0]) {
  97.         // 遇到相同字符，则继续比较后继字符
  98.         if(S[i] == T[j]) {
  99.             i++;
  100.             j++;
  102.             // 遇到不同的字符，则游标需要回退，重新比较
  103.         } else {
  104.             i = i - (j - 1) + 1;    // j-1代表徒劳地前进了j-1个元素，在第j个元素上功亏一篑
  105.             j = 1;                  // 游标j回到串T的第一个位置
  106.         }
  107.     }
  109.     // 增加了一个T[0]>0的判断
  110.     if(j > T[0] && T[0] > 0) {      // T不为空串
  111.         return i - T[0];            // 匹配成功
  112.     } else {
  113.         return 0;
  114.     }
  115. }
  117. /*
  118.  * 插入
  119.  *
  120.  * 将串T插入到主串S的pos位置处。
  121.  */
  122. Status StrInsert(SString S, int pos, SString T) {
  123.     int i;
  125.     if(pos < 1 || pos > S[0] + 1 || S[0] + T[0] > MAXSTRLEN) {
  126.         return ERROR;
  127.     }
  129.     // 如果待插入的串为空，则提前返回
  130.     if(StrEmpty(T)) {
  131.         return OK;
  132.     }
  134.     // 在S中腾出位置，为插入T做准备
  135.     for(i = S[0]; i >= pos; i--) {
  136.         // 从后向前遍历，将前面的元素挪到后面
  137.         S[i + T[0]] = S[i];
  138.     }
  140.     // 将串T插入在S中腾出的位置上
  141.     for(i = pos; i <= pos + T[0] - 1; i++) {
  142.         S[i] = T[i - pos + 1];
  143.     }
  145.     // 长度增加
  146.     S[0] += T[0];
  148.     return OK;
  149. }
  151. /*
  152.  * 删除
  153.  *
  154.  * 删除S[pos, pos+len-1]。
  155.  */
  156. Status StrDelete(SString S, int pos, int len) {
  157.     int i;
  159.     if(pos < 1 || pos + len - 1 > S[0] || len < 0) {
  160.         return ERROR;
  161.     }
  163.     // 如果待删除的长度为0，则提前返回
  164.     if(len == 0) {
  165.         return OK;
  166.     }
  168.     // 把后面的元素挪到前面，覆盖掉被删除的元素
  169.     for(i = pos + len; i <= S[0]; i++) {
  170.         S[i - len] = S[i];
  171.     }
  173.     // 长度减少
  174.     S[0] -= len;
  176.     return OK;
  177. }
  179. /*
  180.  * 比较
  181.  *
  182.  * 比较串S和串T，返回比较结果。
  183.  *
  184.  *【注】
  185.  * 该操作属于最小操作子集
  186.  */
  187. int StrCompare(SString S, SString T) {
  188.     int i = 1;
  190.     while(i <= S[0] && i <= T[0]) {
  191.         // 遇到不同的字符时，比较其大小
  192.         if(S[i] != T[i]) {
  193.             return S[i] - T[i];
  194.         }
  196.         i++;
  197.     }
  199.     return S[0] - T[0];
  200. }
  202. /*
  203.  * 复制
  204.  *
  205.  * 将串S复制到串T。
  206.  */
  207. Status StrCopy(SString T, SString S) {
  208.     int i;
  210.     // 连同长度信息一起复制
  211.     for(i = 0; i <= S[0]; i++) {
  212.         T[i] = S[i];
  213.     }
  215.     return OK;
  216. }
  218. /*
  219.  * 替换
  220.  *
  221.  * 用V替换主串S中出现的所有与T相等的且不重叠的子串。
  222.  *
  223.  *【注】
  224.  * 1.该操作依赖最小操作子集
  225.  * 2.该实现比较低效
  226.  */
  227. Status Replace(SString S, SString T, SString V) {
  228.     int i;
  230.     if(StrEmpty(S) || StrEmpty(T)) {
  231.         return ERROR;
  232.     }
  234.     // 在主串S中寻找模式串T第一次出现的位置
  235.     i = Index_2(S, T, 1);
  237.     // 如果存在匹配的字符串，且可以被完全替换（替换后不溢出）
  238.     while(i != 0 && S[0] - T[0] + V[0] <= MAXSTRLEN) {
  239.         StrDelete(S, i, StrLength(T));  // 从S中删除T
  240.         StrInsert(S, i, V);             // 向S中插入V
  242.         i += StrLength(V);      // i切换到下一个位置
  244.         i = Index_2(S, T, i);   // 查找下一个匹配的字符串
  245.     }
  247.     if(i == 0) {                // S中的T已全部被替换
  248.         return OK;
  249.     } else {                    // S中尚有T，但是V已经插不进去了
  250.         return ERROR;
  251.     }
  252. }
  254. /*
  255.  * ████████ 算法4.2 ████████
  256.  *
  257.  * 串联接
  258.  *
  259.  * 联接S1和S2，并存储到T中返回。如果联接后的长度溢出，则只保留未溢出的部分。
  260.  * 返回值表示联接后的串是否完整。
  261.  *
  262.  *【注】
  263.  * 该操作属于最小操作子集
  264.  */
  265. Status Concat(SString T, SString S1, SString S2) {
  266.     int i;
  267.     int uncut;  // 新串是否完整
  269.     // 完全不需要裁剪
  270.     if(S1[0] + S2[0] <= MAXSTRLEN) {
  271.         // 复制S1到T中
  272.         for(i = 1; i <= S1[0]; i++) {
  273.             T[i] = S1[i];
  274.         }
  276.         // 复制S2到T中
  277.         for(i = S1[0] + 1; i <= S1[0] + S2[0]; i++) {
  278.             T[i] = S2[i - S1[0]];
  279.         }
  281.         // 设置新长度
  282.         T[0] = S1[0] + S2[0];
  284.         // 未裁剪，完整
  285.         uncut = TRUE;
  287.         // 需要裁剪S2
  288.     } else if(S1[0] <= MAXSTRLEN) {
  289.         // 复制S1到T中
  290.         for(i = 1; i <= S1[0]; i++) {
  291.             T[i] = S1[i];
  292.         }
  294.         // 将S2的一部分复制到T中
  295.         for(i = S1[0] + 1; i <= MAXSTRLEN; i++) {
  296.             T[i] = S2[i - S1[0]];
  297.         }
  299.         // 设置新长度
  300.         T[0] = MAXSTRLEN;
  302.         uncut = FALSE;
  304.         // 只需要复制S1的一部分
  305.     } else {
  306.         // 连同长度信息一起复制
  307.         for(i = 0; i <= MAXSTRLEN; i++) {
  308.             T[i] = S1[i];
  309.         }
  311.         uncut = FALSE;
  312.     }
  314.     return uncut;
  315. }
  1. /*
  2.  * 串的堆存储表示
  3.  *
  4.  * 注：有效元素从ch的0号单元开始存储
  5.  */
  6. typedef struct {
  7.     char* ch;           // 若是非空串，则按串长分配存储区，否则ch为NULL
  8.     int length;
  9. } HString;
  11. /*
  12.  * 求子串
  13.  *
  14.  * 用Sub返回S[pos, pos+len-1]。
  15.  * 返回值指示是否截取成功。
  16.  *
  17.  *【注】
  18.  * 该操作属于最小操作子集
  19.  */
  20. Status SubString(HString* Sub, HString S, int pos, int len) {
  21.     int i;
  23.     if(pos < 1 || pos > S.length || len < 0 || pos + len - 1 > S.length) {
  24.         return ERROR;
  25.     }
  27.     // 如果是截取0个字符，不需要分配空间
  28.     if(len == 0) {
  29.         (*Sub).ch = NULL;
  30.         (*Sub).length = 0;
  32.         return OK;
  33.     }
  35.     (*Sub).ch = (char*) malloc(len * sizeof(char));
  36.     if(!(*Sub).ch) {
  37.         exit(OVERFLOW);
  38.     }
  40.     // 复制元素
  41.     for(i = 0; i < len; i++) {
  42.         (*Sub).ch[i] = S.ch[i + pos - 1];
  43.     }
  45.     // 确定新长度
  46.     (*Sub).length = len;
  48.     return OK;
  49. }
  51. /*
  52.  * 查找
  53.  *
  54.  * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
  55.  * 如果查找成功，返回匹配的位置。
  56.  *
  57.  *【注】
  58.  * 1.此实现需要依赖串的最小操作子集
  59.  * 2.该实现比较低效
  60.  */
  61. int Index(HString S, HString T, int pos) {
  62.     int i, s, t;
  63.     HString sub;
  65.     if(pos < 1 || pos > S.length || StrEmpty(T)) {
  66.         return 0;
  67.     }
  69.     s = S.length;
  70.     t = T.length;
  71.     i = pos;
  73.     // 保证长度不越界
  74.     while(i + t - 1 <= s) {
  75.         // 获取S[i, i+t-1]
  76.         SubString(&sub, S, i, t);
  78.         // 如果子串与模式串不匹配，则需要继续推进
  79.         if(StrCompare(sub, T) != 0) {
  80.             ++i;
  81.         } else {
  82.             return i;
  83.         }
  84.     }
  86.     return 0;
  87. }
  89. /*
  90.  * ████████ 算法4.4 ████████
  91.  *
  92.  * 插入
  93.  *
  94.  * 将串T插入到主串S的pos位置处。
  95.  */
  96. Status StrInsert(HString* S, int pos, HString T) {
  97.     int i;
  99.     if(pos < 1 || pos > (*S).length + 1) {
  100.         return ERROR;
  101.     }
  103.     // 如果待插入的串为空，则提前返回
  104.     if(StrEmpty(T)) {
  105.         return OK;
  106.     }
  108.     // 分配新空间，会将旧元素一起复制过去
  109.     (*S).ch = (char*) realloc((*S).ch, ((*S).length + T.length) * sizeof(char));
  110.     if(!(*S).ch) {
  111.         exit(OVERFLOW);
  112.     }
  114.     // 在S中腾出位置，为插入T做准备
  115.     for(i = (*S).length - 1; i >= pos - 1; i--) {
  116.         // 从后向前遍历，将前面的元素挪到后面
  117.         (*S).ch[i + T.length] = (*S).ch[i];
  118.     }
  120.     // 将串T插入在S中腾出的位置上
  121.     for(i = pos - 1; i <= pos + T.length - 2; i++) {
  122.         (*S).ch[i] = T.ch[i - pos + 1];
  123.     }
  125.     // 长度增加
  126.     (*S).length += T.length;
  128.     return OK;
  129. }
  131. /*
  132.  * 删除
  133.  *
  134.  * 删除S[pos, pos+len-1]。
  135.  */
  136. Status StrDelete(HString* S, int pos, int len) {
  137.     int i;
  139.     if(pos < 1 || pos + len - 1 > (*S).length || len < 0) {
  140.         return ERROR;
  141.     }
  143.     // 如果待删除的长度为0，则提前返回
  144.     if(len == 0) {
  145.         return OK;
  146.     }
  148.     // 把后面的元素挪到前面，覆盖掉被删除的元素
  149.     for(i = pos + len - 1; i <= (*S).length - 1; i++) {
  150.         (*S).ch[i - len] = (*S).ch[i];
  151.     }
  153.     // 长度减少
  154.     (*S).length -= len;
  156.     // 缩减分配的空间（如果长度减少为0，这里会返回空指针）
  157.     (*S).ch = (char*) realloc((*S).ch, (*S).length * sizeof(char));
  159.     return OK;
  160. }
  162. /*
  163.  * 比较
  164.  *
  165.  * 比较串S和串T，返回比较结果。
  166.  *
  167.  *【注】
  168.  * 该操作属于最小操作子集
  169.  */
  170. Status StrCompare(HString S, HString T) {
  171.     int i;
  173.     for(i = 0; i < S.length && i < T.length; i++) {
  174.         // 遇到不同的字符时，比较其大小
  175.         if(S.ch[i] != T.ch[i]) {
  176.             return S.ch[i] - T.ch[i];
  177.         }
  178.     }
  180.     return S.length - T.length;
  181. }
  183. /*
  184.  * 复制
  185.  *
  186.  * 将串S复制到串T。
  187.  */
  188. Status StrCopy(HString* T, HString S) {
  189.     int i;
  191.     if(StrEmpty(S)) {
  192.         (*T).ch = NULL;
  193.         (*T).length = 0;
  194.     } else {
  195.         // 分配空间
  196.         (*T).ch = (char*) malloc(S.length * sizeof(char));
  197.         if(!(*T).ch) {
  198.             exit(OVERFLOW);
  199.         }
  201.         // 复制元素
  202.         for(i = 0; i < S.length; i++) {
  203.             (*T).ch[i] = S.ch[i];
  204.         }
  206.         // 复制长度信息
  207.         (*T).length = S.length;
  208.     }
  210.     return OK;
  211. }
  213. /*
  214.  * 替换
  215.  *
  216.  * 用V替换主串S中出现的所有与T相等的且不重叠的子串。
  217.  *
  218.  *【注】
  219.  * 1.该操作依赖最小操作子集
  220.  * 2.该实现比较低效
  221.  */
  222. Status Replace(HString* S, HString T, HString V) {
  223.     int i;
  225.     if(StrEmpty(*S) || StrEmpty(T)) {
  226.         return ERROR;
  227.     }
  229.     // 在主串S中寻找模式串T第一次出现的位置
  230.     i = Index(*S, T, 1);
  232.     // 如果存在匹配的字符串
  233.     while(i != 0) {
  234.         StrDelete(S, i, StrLength(T));  // 从S中删除T
  235.         StrInsert(S, i, V);             // 向S中插入V
  237.         i += StrLength(V);          // i切换到下一个位置
  239.         i = Index(*S, T, i);        // 查找下一个匹配的字符串
  240.     }
  242.     return OK;
  243. }
  245. /*
  246.  * 串联接
  247.  *
  248.  * 联接S1和S2，并存储到T中返回。如果联接后的长度溢出，则只保留未溢出的部分。
  249.  * 返回值表示联接后的串是否完整。
  250.  * 堆串的空间被认为是无限的，因此这里总是返回TRUE，指示串不会被裁剪。
  251.  *
  252.  *【注】
  253.  * 该操作属于最小操作子集
  254.  */
  255. Status Concat(HString* T, HString S1, HString S2) {
  256.     int i;
  258.     // 确定新长度
  259.     (*T).length = S1.length + S2.length;
  261.     // 分配空间
  262.     (*T).ch = (char*) malloc((*T).length * sizeof(char));
  263.     if(!(*T).ch) {
  264.         exit(OVERFLOW);
  265.     }
  267.     // 先把S1的内容拷贝出来
  268.     for(i = 0; i < S1.length; i++) {
  269.         (*T).ch[i] = S1.ch[i];
  270.     }
  272.     // 再拷贝S2的内容
  273.     for(i = 0; i < S2.length; i++) {
  274.         (*T).ch[S1.length + i] = S2.ch[i];
  275.     }
  277.     return TRUE;
  278. }

串的模式匹配（next[j]值求解）
复习提要（20级） - 图3:其值 = 第复习提要（20级） - 图4位字符前面复习提要（20级） - 图5位字符组成的子串的前后缀重合字符数+1

  1. #include "SString.h"     
  2. /*
  3.  * ████████ 算法4.6 ████████
  4.  *
  5.  * 查找
  6.  *
  7.  * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
  8.  * 如果查找成功，返回匹配的位置。
  9.  *
  10.  *【注】
  11.  * 1.该实现用到了KMP算法，是一种比较高效的字符串匹配方式
  12.  * 2.教材中没有next参数
  13.  */
  14. int Index_KMP(SString S, SString T, int pos, int next[]) {
  15.     int i = pos;
  16.     int j = 1;
  18.     if(pos < 1) {
  19.         return 0;
  20.     }
  22.     // 比较字符串
  23.     while(i <= S[0] && j <= T[0]) {
  24.         /*
  25.          * 两种情形：
  26.          * 1.在模式串的第一个字符处就失配
  27.          * 2.主串和模式串处的字符相等
  28.          */
  29.         if(j == 0 || S[i] == T[j]) {
  30.             i++;
  31.             j++;
  32.         } else {
  33.             // 失配时回到前一个适当的位置
  34.             j = next[j];
  35.         }
  36.     }
  38.     if(j > T[0]) {
  39.         // 匹配成功，返回匹配位置
  40.         return i - T[0];
  41.     } else {
  42.         // 匹配失败
  43.         return 0;
  44.     }
  45. }
  47. /*
  48.  * ████████ 算法4.7 ████████
  49.  *
  50.  * 计算模式串的“失配数组”，用于KMP算法。
  51.  */
  52. void get_next(SString T, int next[]) {
  53.     int i = 1;
  54.     int j = 0;
  56.     // 模式串第一个字符处失配时，模式串需要从头比较，主串需要前进到下一个位置比较
  57.     next[1] = 0;
  59.     // 遍历模式串上的字符
  60.     while(i < T[0]) {
  61.         if(j == 0 || T[i] == T[j]) {
  62.             i++;
  63.             j++;
  64.             next[i] = j;
  65.         } else {
  66.             j = next[j];
  67.         }
  68.     }
  69. }
  71. /*
  72.  * ████████ 算法4.8 ████████
  73.  *
  74.  * 计算模式串的“失配数组”，用于KMP算法。
  75.  * 这是一个优化后的版本，效率较算法4.7有所提高。
  76.  */
  77. void get_nextval(SString T, int nextval[]) {
  78.     int i = 1;
  79.     int j = 0;
  81.     // 模式串第一个字符处失配时，模式串需要从头比较，主串需要前进到下一个位置比较
  82.     nextval[1] = 0;
  84.     // 遍历模式串上的字符
  85.     while(i < T[0]) {
  86.         if(j==0 || T[i] == T[j]) {
  87.             i++;
  88.             j++;
  90.             if(T[i] != T[j]) {
  91.                 nextval[i] = j;
  92.             } else {
  93.                 nextval[i] = nextval[j];
  94.             }
  95.         } else {
  96.             j = nextval[j];
  97.         }
  98.     }
  99. }

KMP

第五章 数组

数组元素地址的计算
1)按行序存储

如果按行序存储，怎么找到复习提要（20级） - 图6的存储位置呢？

先看看存储复习提要（20级） - 图7之前，前面已经存储了多少个元素，如图所示。
image.png
从图可以看出，在复习提要（20级） - 图9之前一共有i×n+j个元素，如果每个元素占用L字节，那么共需要(i×n+j)×L字节，只需要用基地址加上这些字节就可以得到复习提要（20级） - 图10的存储地址了。按行序存储，复习提要（20级） - 图11的存储地址为：
image.png
复习提要（20级） - 图13表示第一个元素的存储地址，即基地址，复习提要（20级） - 图14表示复习提要（20级） - 图15的存储地址。

2)按列序存储

如果按列序存储，怎么找到复习提要（20级） - 图16的存储位置呢？

先看看存储复习提要（20级） - 图17之前，前面已经存储了多少个元素，如图所示。
image.png
从图可以看出，在复习提要（20级） - 图19之前一共有j×m+i个元素，如果每个元素占用L字节，那么共需要(j×m+i)×L字节，只需要用基地址加上这些字节就可以得到复习提要（20级） - 图20的存储地址了。按列序存储，复习提要（20级） - 图21的存储地址为：
image.png
复习提要（20级） - 图23表示第一个元素的存储地址，即基地址，复习提要（20级） - 图24表示aij的存储地址。

注意：如果二维数组的下标是从1开始的，那么情形就变了。 先看看存储复习提要（20级） - 图25之前，前面已经存储了多少个元素，如图所示。 image.png 从图可以看出，行数和个数都少1，在aij之前一共有(i−1)×n+j−1个元素，如果每个元素占用L字节，那么共需要((i−1)×n+j−1)×L字节，只需要用基地址加上这些字节就可以得到复习提要（20级） - 图27的存储地址了。如果二维数组下标从1开始，按行序存储，复习提要（20级） - 图28的存储地址为： image.png

存储地址计算秘籍：
复习提要（20级） - 图30的存储地址等于第一个元素的存储地址，加上前面的元素个数乘以每个元素占用的字节数。计算公式为：
image.png

稀疏矩阵的压缩存储

  1. /* 三元组类型定义，主要用来存储非零元 */
  2. typedef struct {
  3.     int i, j;       // 该三元组非零元的行下标和列下标
  4.     ElemType e;
  5. } Triple;
  7. /* 三元组稀疏矩阵类型定义 */
  8. typedef struct {
  9.     Triple data[MAXSIZE + 1];   // 非零元三元组表，data[0]未用
  10.     int mu, nu, tu;             // 矩阵的行数、列数和非零元个数
  11. } TSMatrix;
  13. /*
  14.  * 创建稀疏矩阵M
  15.  *
  16.  *
  17.  *【备注】
  18.  *
  19.  * 教材中默认从控制台读取数据。
  20.  * 这里为了方便测试，避免每次运行都手动输入数据，
  21.  * 因而允许选择从预设的文件path中读取测试数据。
  22.  *
  23.  * 如果需要从控制台读取数据，则path为NULL或者为空串，
  24.  * 如果需要从文件中读取数据，则需要在path中填写文件名信息。
  25.  */
  26. Status CreateSMatrix(TSMatrix* M, char* path) {
  27.     int k;
  28.     FILE* fp;
  29.     int readFromConsole;    // 是否从控制台读取数据
  31.     // 如果没有文件路径信息，则从控制台读取输入
  32.     readFromConsole = path == NULL || strcmp(path, "") == 0;
  34.     // 如果没有文件路径信息，则从控制台读取输入
  35.     if(readFromConsole) {
  36.         printf("请输入行数：");
  37.         scanf("%d", &((*M).mu));
  38.         printf("请输入列数：");
  39.         scanf("%d", &((*M).nu));
  40.         printf("请输入非零元素个数：");
  41.         scanf("%d", &((*M).tu));
  42.         printf("请输入%d个三元组信息\n", (*M).tu);
  43.         for(k = 1; k <= (*M).tu; k++) {
  44.             printf("第%2d组：", k);
  45.             scanf("%d%d%d", &((*M).data[k].i), &((*M).data[k].j), &((*M).data[k].e));
  46.         }
  47.     } else {
  48.         fp = fopen(path, "r");
  50.         ReadData(fp, "%d%d%d", &((*M).mu), &((*M).nu), &((*M).tu));
  52.         for(k = 1; k <= (*M).tu; k++) {
  53.             ReadData(fp, "%d%d%d", &((*M).data[k].i), &((*M).data[k].j), &((*M).data[k].e));
  54.         }
  56.         fclose(fp);
  57.     }
  59.     return OK;
  60. }
  62. /*
  63.  * 矩阵复制
  64.  *
  65.  * 创建一个新矩阵T，该矩阵包含了从矩阵M中包含的数据。
  66.  */
  67. Status CopySMatrix(TSMatrix M, TSMatrix* T) {
  68.     (*T) = M;   // 结构体之间可以直接复制，即使内部包含数组也可以
  70.     return OK;
  71. }
  73. /*
  74.  * 矩阵加法
  75.  *
  76.  * Q = M + N。
  77.  */
  78. Status AddSMatrix(TSMatrix M, TSMatrix N, TSMatrix* Q) {
  79.     int m, n, k;
  81.     if(M.mu != N.mu || M.nu != N.nu) {
  82.         printf("两矩阵的行数、列数不满足相加条件！！\n");
  83.         return ERROR;
  84.     }
  86.     // 初始化Q
  87.     (*Q).mu = M.mu;
  88.     (*Q).nu = M.nu;
  89.     (*Q).tu = 0;
  91.     m = n = k = 1;
  93.     // 依次遍历M与N的三元组
  94.     while(m <= M.tu && n <= N.tu) {
  95.         // M中的三元组行下标较小
  96.         if(M.data[m].i < N.data[n].i) {
  97.             (*Q).data[k] = M.data[m];
  98.             m++;
  100.             // N中的三元组行下标较小
  101.         } else if(M.data[m].i > N.data[n].i) {
  102.             (*Q).data[k] = N.data[n];
  103.             n++;
  105.             // M与N中的三元组行下标一致，需要进一步比较列坐标
  106.         } else {
  107.             // M中的三元组列下标较小
  108.             if(M.data[m].j < N.data[n].j) {
  109.                 (*Q).data[k] = M.data[m];
  110.                 m++;
  112.                 // N中的三元组列下标较小
  113.             } else if(M.data[m].j > N.data[n].j) {
  114.                 (*Q).data[k] = N.data[n];
  115.                 n++;
  117.                 // M与N中的三元组列下标一致，需要进行加法运算
  118.             } else {
  119.                 // 值已经加为0的话，不需要存储该元素
  120.                 if((M.data[m].e + N.data[n].e) == 0) {
  121.                     m++;
  122.                     n++;
  123.                     continue;
  124.                 } else {
  125.                     (*Q).data[k].i = M.data[m].i;
  126.                     (*Q).data[k].j = M.data[m].j;
  127.                     (*Q).data[k].e = M.data[m].e + N.data[n].e;
  128.                     m++;
  129.                     n++;
  130.                 }
  131.             }
  132.         }
  134.         k++;
  135.         (*Q).tu++;
  136.     }
  138.     // 遍历M中剩余的三元组
  139.     while(m <= M.tu) {
  140.         (*Q).data[k] = M.data[m];
  141.         m++;
  142.         k++;
  143.         (*Q).tu++;
  144.     }
  146.     // 遍历N中剩余的三元组
  147.     while(n <= N.tu) {
  148.         (*Q).data[k] = N.data[n];
  149.         n++;
  150.         k++;
  151.         (*Q).tu++;
  152.     }
  154.     return OK;
  155. }
  157. /*
  158.  * 矩阵减法
  159.  *
  160.  * Q = M - N。
  161.  */
  162. Status SubSMatrix(TSMatrix M, TSMatrix N, TSMatrix* Q) {
  163.     int m, n, k;
  165.     if(M.mu != N.mu || M.nu != N.nu) {
  166.         printf("两矩阵的行数、列数不满足相减条件！！\n");
  167.         return ERROR;
  168.     }
  170.     // 初始化Q
  171.     (*Q).mu = M.mu;
  172.     (*Q).nu = M.nu;
  173.     (*Q).tu = 0;
  175.     m = n = k = 1;
  177.     // 依次遍历M与N的三元组
  178.     while(m <= M.tu && n <= N.tu) {
  179.         // M中的三元组行下标较小
  180.         if(M.data[m].i < N.data[n].i) {
  181.             (*Q).data[k] = M.data[m];
  182.             m++;
  184.             // N中的三元组行下标较小
  185.         } else if(M.data[m].i > N.data[n].i) {
  186.             (*Q).data[k].i = N.data[n].i;
  187.             (*Q).data[k].j = N.data[n].j;
  188.             (*Q).data[k].e = -N.data[n].e;  // 由于是相减，所以要对元素值取相反数
  189.             n++;
  191.             // M与N中的三元组行下标一致，需要进一步比较列坐标
  192.         } else {
  193.             // M中的三元组列下标较小
  194.             if(M.data[m].j < N.data[n].j) {
  195.                 (*Q).data[k] = M.data[m];
  196.                 m++;
  198.                 // N中的三元组列下标较小
  199.             } else if(M.data[m].j > N.data[n].j) {
  200.                 (*Q).data[k].i = N.data[n].i;
  201.                 (*Q).data[k].j = N.data[n].j;
  202.                 (*Q).data[k].e = -N.data[n].e;  // 由于是相减，所以要对元素值取相反数
  203.                 n++;
  205.                 // M与N中的三元组列下标一致，需要进行减法运算
  206.             } else {
  207.                 // 值已经减为0的话，不需要存储该元素
  208.                 if((M.data[m].e - N.data[n].e) == 0) {
  209.                     m++;
  210.                     n++;
  211.                     continue;
  212.                 } else {
  213.                     (*Q).data[k].i = M.data[m].i;
  214.                     (*Q).data[k].j = M.data[m].j;
  215.                     (*Q).data[k].e = M.data[m].e - N.data[n].e;
  216.                     m++;
  217.                     n++;
  218.                 }
  219.             }
  220.         }
  222.         k++;
  223.         (*Q).tu++;
  224.     }
  226.     // 遍历M中剩余的三元组
  227.     while(m <= M.tu) {
  228.         (*Q).data[k] = M.data[m];
  229.         m++;
  230.         k++;
  231.         (*Q).tu++;
  232.     }
  234.     // 遍历N中剩余的三元组
  235.     while(n <= N.tu) {
  236.         (*Q).data[k].i = N.data[n].i;
  237.         (*Q).data[k].j = N.data[n].j;
  238.         (*Q).data[k].e = -N.data[n].e;
  239.         n++;
  240.         k++;
  241.         (*Q).tu++;
  242.     }
  244.     return OK;
  245. }
  247. /*
  248.  * 矩阵乘法
  249.  *
  250.  * Q = M * N，这里实现的是传统矩阵乘法。
  251.  */
  252. Status MultSMatrix(TSMatrix M, TSMatrix N, TSMatrix* Q) {
  253.     int m, n, i, j, k;
  254.     ElemType c, c1, c2;
  256.     // M的列数需要等于N的行数
  257.     if(M.nu != N.mu) {
  258.         printf("两矩阵的行数、列数不满足相乘条件！！\n");
  259.         return ERROR;
  260.     }
  262.     // 初始化Q
  263.     (*Q).mu = M.mu;
  264.     (*Q).nu = N.nu;
  265.     (*Q).tu = 0;
  267.     // 如果存在零矩阵
  268.     if(M.tu * N.tu == 0) {
  269.         return OK;
  270.     }
  272.     // 遍历矩阵M的行
  273.     for(i = 1; i <= M.mu; i++) {
  274.         // 遍历矩阵N的列
  275.         for(j = 1; j <= N.nu; j++) {
  276.             c = 0;
  277.             for(k = 1; k <= M.nu; k++) {
  278.                 // 记录M[i][k]的值
  279.                 c1 = 0;
  280.                 // 依次寻找位于指定位置的M三元组
  281.                 for(m = 1; m <= M.tu; m++) {
  282.                     if(M.data[m].i == i && M.data[m].j == k) {
  283.                         c1 = M.data[m].e;
  284.                         break;
  285.                     }
  286.                 }
  288.                 // 记录N[k][j]的值
  289.                 c2 = 0;
  290.                 //依次寻找位于指定位置的N三元组
  291.                 for(n = 1; n <= N.tu; n++) {
  292.                     if(N.data[n].i == k && N.data[n].j == j) {
  293.                         c2 = N.data[n].e;
  294.                         break;
  295.                     }
  296.                 }
  298.                 // 计算Q[i][j]的值
  299.                 if(c1 && c2) {
  300.                     c += c1 * c2;
  301.                 }
  302.             }
  304.             // 如果计算结果不为0，则进行存储
  305.             if(c != 0) {
  306.                 (*Q).tu++;
  307.                 (*Q).data[(*Q).tu].i = i;
  308.                 (*Q).data[(*Q).tu].j = j;
  309.                 (*Q).data[(*Q).tu].e = c;
  310.             }
  311.         }
  312.     }
  314.     return OK;
  315. }
  317. /*
  318.  * ████████ 算法5.1 ████████
  319.  *
  320.  * 矩阵转置
  321.  */
  322. Status TransposeSMatrix(TSMatrix M, TSMatrix* T) {
  323.     int p, q, col;
  325.     (*T).mu = M.nu;
  326.     (*T).nu = M.mu;
  327.     (*T).tu = M.tu;
  329.     if((*T).tu != 0) {
  330.         q = 1;  // q用于T中非零元的计数
  332.         // col代表M的列，T的行
  333.         for(col = 1; col <= M.nu; ++col) {
  334.             // 在M中查找第j列的元素，依次将其转置到T中
  335.             for(p = 1; p <= M.tu; ++p) {
  336.                 if(M.data[p].j == col) {
  337.                     (*T).data[q].i = M.data[p].j;    // M的列变为T的行
  338.                     (*T).data[q].j = M.data[p].i;    // M的行变为T的列
  339.                     (*T).data[q].e = M.data[p].e;    // 每个三元组值不变
  340.                     ++q;
  341.                 }
  342.             }
  343.         }
  344.     }
  346.     return OK;
  347. }
  349. /*
  350.  * ████████ 算法5.2 ████████
  351.  *
  352.  * 矩阵快速转置
  353.  */
  354. Status FastTransposeSMatrix(TSMatrix M, TSMatrix* T) {
  355.     int col, t, p, q;
  356.     int* num;       // num[col] 表示M第col列中非零元的个数
  357.     int* copt;      // copt[col]表示M第col列第一个非零元在转置后矩阵中的位置
  359.     (*T).mu = M.nu;
  360.     (*T).nu = M.mu;
  361.     (*T).tu = M.tu;
  363.     // 提前返回
  364.     if((*T).tu == 0) {
  365.         return ERROR;
  366.     }
  368.     num  = (int*) malloc((M.nu + 1) * sizeof(int));
  369.     copt = (int*) malloc((M.nu + 1) * sizeof(int));
  371.     // 初始化数组num
  372.     for(col = 1; col <= M.nu; ++col) {
  373.         num[col] = 0;
  374.     }
  376.     // 统计M中的非零元，统计每列非零元的个数
  377.     for(t = 1; t <= M.tu; ++t) {
  378.         num[M.data[t].j]++;
  379.     }
  381.     // 第1列第1个非零元总是位于转置后矩阵中的首位
  382.     copt[1] = 1;
  383.     // 计算各列第1个非零元在转置矩阵中的位置
  384.     for(col = 2; col <= M.nu; ++col) {
  385.         copt[col] = copt[col - 1] + num[col - 1];
  386.     }
  388.     // 依次扫描M中的三元组
  389.     for(p = 1; p <= M.tu; ++p) {
  390.         col = M.data[p].j;                // 计算当前非零元所处的列
  391.         q = copt[col];                    // 计算当前非零元在转置矩阵中的位置
  392.         (*T).data[q].i = M.data[p].j;
  393.         (*T).data[q].j = M.data[p].i;
  394.         (*T).data[q].e = M.data[p].e;
  395.         ++copt[col];                      // 再遇到此列元素时，其在转置矩阵中的位置应当增一（该步骤很重要）
  396.     }
  398.     return OK;
  399. }
  401. /*
  402.  * 输出矩阵
  403.  */
  404. void PrintSMatrix(TSMatrix M) {
  405.     int r, c;
  406.     int k = 1;
  408.     for(r = 1; r <= M.mu; r++) {
  409.         for(c = 1; c <= M.nu; c++) {
  410.             if(r == M.data[k].i && c == M.data[k].j) {
  411.                 printf("%3d ", M.data[k].e);
  412.                 k++;
  413.             } else {
  414.                 printf("%3d ", 0);
  415.             }
  416.         }
  417.         printf("\n");
  418.     }
  419. }
  1. /* 三元组类型定义，主要用来存储非零元 */
  2. typedef struct {
  3.     int i, j;       // 该非零元的行下标和列下标
  4.     ElemType e;
  5. } Triple;
  7. /* 行逻辑链接的稀疏矩阵类型定义 */
  8. typedef struct {
  9.     Triple data[MAXSIZE + 1];   // 非零元三元组表，data[0]未用
  10.     int rpos[MAXRC + 1];        // 各行第一个非零元在三元组表中的位置表，rpos[0]未用
  11.     int mu, nu, tu;             // 矩阵的行数、列数和非零元个数
  12. } RLSMatrix;
  14. /*
  15.  * 创建稀疏矩阵M
  16.  *
  17.  *
  18.  *【备注】
  19.  *
  20.  * 教材中默认从控制台读取数据。
  21.  * 这里为了方便测试，避免每次运行都手动输入数据，
  22.  * 因而允许选择从预设的文件path中读取测试数据。
  23.  *
  24.  * 如果需要从控制台读取数据，则path为NULL或者为空串，
  25.  * 如果需要从文件中读取数据，则需要在path中填写文件名信息。
  26.  */
  27. Status CreateSMatrix(RLSMatrix* M, char* path) {
  28.     int k;
  29.     FILE* fp;
  30.     int readFromConsole;    // 是否从控制台读取数据
  32.     // 如果没有文件路径信息，则从控制台读取输入
  33.     readFromConsole = path == NULL || strcmp(path, "") == 0;
  35.     // 如果没有文件路径信息，则从控制台读取输入
  36.     if(readFromConsole) {
  37.         printf("请输入行数：");
  38.         scanf("%d", &((*M).mu));
  39.         printf("请输入列数：");
  40.         scanf("%d", &((*M).nu));
  41.         printf("请输入非零元素个数：");
  42.         scanf("%d", &((*M).tu));
  43.         printf("请输入%d个三元组信息\n", (*M).tu);
  44.         for(k = 1; k <= (*M).tu; k++) {
  45.             printf("第%2d组：", k);
  46.             scanf("%d%d%d", &((*M).data[k].i), &((*M).data[k].j), &((*M).data[k].e));
  47.         }
  48.     } else {
  49.         fp = fopen(path, "r");
  51.         ReadData(fp, "%d%d%d", &((*M).mu), &((*M).nu), &((*M).tu));
  53.         for(k = 1; k <= (*M).tu; k++) {
  54.             ReadData(fp, "%d%d%d", &((*M).data[k].i), &((*M).data[k].j), &((*M).data[k].e));
  55.         }
  57.         fclose(fp);
  58.     }
  60.     // 为rpos数组赋值
  61.     AssignRpos(M);
  63.     return OK;
  64. }
  66. /*
  67.  * 矩阵加法
  68.  *
  69.  * Q = M + N。
  70.  */
  71. Status AddSMatrix(RLSMatrix M, RLSMatrix N, RLSMatrix* Q) {
  72.     int m, n, k;
  74.     if(M.mu != N.mu || M.nu != N.nu) {
  75.         printf("两矩阵的行数、列数不满足相加条件！！\n");
  76.         return ERROR;
  77.     }
  79.     // 初始化Q的行列信息
  80.     (*Q).mu = M.mu;
  81.     (*Q).nu = M.nu;
  82.     (*Q).tu = 0;
  84.     m = n = k = 1;
  86.     // 依次遍历M与N的三元组
  87.     while(m <= M.tu && n <= N.tu) {
  88.         // M中的三元组行下标较小
  89.         if(M.data[m].i < N.data[n].i) {
  90.             (*Q).data[k] = M.data[m];
  91.             m++;
  93.             // N中的三元组行下标较小
  94.         } else if(M.data[m].i > N.data[n].i) {
  95.             (*Q).data[k] = N.data[n];
  96.             n++;
  98.             // M与N中的三元组行下标一致，需要进一步比较列坐标
  99.         } else {
  100.             // M中的三元组列下标较小
  101.             if(M.data[m].j < N.data[n].j) {
  102.                 (*Q).data[k] = M.data[m];
  103.                 m++;
  105.                 // N中的三元组列下标较小
  106.             } else if(M.data[m].j > N.data[n].j) {
  107.                 (*Q).data[k] = N.data[n];
  108.                 n++;
  110.                 // M与N中的三元组列下标一致，需要进行加法运算
  111.             } else {
  112.                 // 值已经加为0的话，不需要存储该元素
  113.                 if((M.data[m].e + N.data[n].e) == 0) {
  114.                     m++;
  115.                     n++;
  116.                     continue;
  117.                 } else {
  118.                     (*Q).data[k].i = M.data[m].i;
  119.                     (*Q).data[k].j = M.data[m].j;
  120.                     (*Q).data[k].e = M.data[m].e + N.data[n].e;
  121.                     m++;
  122.                     n++;
  123.                 }
  124.             }
  125.         }
  127.         k++;
  128.         (*Q).tu++;
  129.     }
  131.     // 遍历M中剩余的三元组
  132.     while(m <= M.tu) {
  133.         (*Q).data[k] = M.data[m];
  134.         m++;
  135.         k++;
  136.         (*Q).tu++;
  137.     }
  139.     // 遍历N中剩余的三元组
  140.     while(n <= N.tu) {
  141.         (*Q).data[k] = N.data[n];
  142.         n++;
  143.         k++;
  144.         (*Q).tu++;
  145.     }
  147.     // 为rpos数组赋值
  148.     AssignRpos(Q);
  150.     return OK;
  151. }
  153. /*
  154.  * 矩阵减法
  155.  *
  156.  * Q = M - N。
  157.  */
  158. Status SubSMatrix(RLSMatrix M, RLSMatrix N, RLSMatrix* Q) {
  159.     int m, n, k;
  161.     if(M.mu != N.mu || M.nu != N.nu) {
  162.         printf("两矩阵的行数、列数不满足相减条件！！\n");
  163.         return ERROR;
  164.     }
  166.     // 初始化Q的行列信息
  167.     (*Q).mu = M.mu;
  168.     (*Q).nu = M.nu;
  169.     (*Q).tu = 0;
  171.     m = n = k = 1;
  173.     // 依次遍历M与N的三元组
  174.     while(m <= M.tu && n <= N.tu) {
  175.         // M中的三元组行下标较小
  176.         if(M.data[m].i < N.data[n].i) {
  177.             (*Q).data[k] = M.data[m];
  178.             m++;
  180.             // N中的三元组行下标较小
  181.         } else if(M.data[m].i > N.data[n].i) {
  182.             (*Q).data[k].i = N.data[n].i;
  183.             (*Q).data[k].j = N.data[n].j;
  184.             (*Q).data[k].e = -N.data[n].e;  // 由于是相减，所以要对元素值取相反数
  185.             n++;
  187.             // M与N中的三元组行下标一致，需要进一步比较列坐标
  188.         } else {
  189.             // M中的三元组列下标较小
  190.             if(M.data[m].j < N.data[n].j) {
  191.                 (*Q).data[k] = M.data[m];
  192.                 m++;
  194.                 // N中的三元组列下标较小
  195.             } else if(M.data[m].j > N.data[n].j) {
  196.                 (*Q).data[k].i = N.data[n].i;
  197.                 (*Q).data[k].j = N.data[n].j;
  198.                 (*Q).data[k].e = -N.data[n].e;  // 由于是相减，所以要对元素值取相反数
  199.                 n++;
  201.                 // M与N中的三元组列下标一致，需要进行减法运算
  202.             } else {
  203.                 // 值已经减为0的话，不需要存储该元素
  204.                 if((M.data[m].e - N.data[n].e) == 0) {
  205.                     m++;
  206.                     n++;
  207.                     continue;
  208.                 } else {
  209.                     (*Q).data[k].i = M.data[m].i;
  210.                     (*Q).data[k].j = M.data[m].j;
  211.                     (*Q).data[k].e = M.data[m].e - N.data[n].e;
  212.                     m++;
  213.                     n++;
  214.                 }
  215.             }
  216.         }
  218.         k++;
  219.         (*Q).tu++;
  220.     }
  222.     // 遍历M中剩余的三元组
  223.     while(m <= M.tu) {
  224.         (*Q).data[k] = M.data[m];
  225.         m++;
  226.         k++;
  227.         (*Q).tu++;
  228.     }
  230.     // 遍历N中剩余的三元组
  231.     while(n <= N.tu) {
  232.         (*Q).data[k].i = N.data[n].i;
  233.         (*Q).data[k].j = N.data[n].j;
  234.         (*Q).data[k].e = -N.data[n].e;
  235.         n++;
  236.         k++;
  237.         (*Q).tu++;
  238.     }
  240.     // 为rpos数组赋值
  241.     AssignRpos(Q);
  243.     return OK;
  244. }
  246. /*
  247.  * ████████ 算法5.3 ████████
  248.  *
  249.  * 矩阵乘法
  250.  *
  251.  * Q = M * N。
  252.  */
  253. Status MultSMatrix(RLSMatrix M, RLSMatrix N, RLSMatrix* Q) {
  254.     int arow, p, tp;
  255.     int brow, q, tq;
  256.     int ccol;
  257.     int* ctemp;    // Q中各行元素值累加器，ctemp[0]单元弃用
  258.     int i;
  260.     // M的列数需要等于N的行数
  261.     if(M.nu != N.mu) {
  262.         printf("两矩阵的行数、列数不满足相乘条件！！\n");
  263.         return ERROR;
  264.     }
  266.     // 初始化Q的行列信息
  267.     (*Q).mu = M.mu;
  268.     (*Q).nu = N.nu;
  269.     (*Q).tu = 0;
  271.     // 如果存在零矩阵
  272.     if(M.tu * N.tu == 0) {
  273.         return OK;
  274.     }
  276.     ctemp = (int*) malloc((N.nu + 1) * sizeof(int));
  278.     // 处理M的每一行
  279.     for(arow = 1; arow <= M.mu; ++arow) {
  280.         // 初始化Q中行元素值计数器
  281.         for(i = 0; i <= N.nu; ++i) {
  282.             ctemp[i] = 0;
  283.         }
  285.         // tp指向M当前行的下一行第一个非零元位置
  286.         if(arow < M.mu) {
  287.             tp = M.rpos[arow + 1];
  288.         } else {
  289.             tp = M.tu + 1;
  290.         }
  292.         // 遍历M中arow行的所有非零元
  293.         for(p = M.rpos[arow]; p < tp; ++p) {
  294.             // 获取该非零元在N中的行号
  295.             brow = M.data[p].j;
  297.             // tq指向N当前行的下一行第一个非零元位置
  298.             if(brow < N.mu) {
  299.                 tq = N.rpos[brow + 1];
  300.             } else {
  301.                 tq = N.tu + 1;
  302.             }
  304.             // 遍历N中brow行的所有非零元
  305.             for(q = N.rpos[brow]; q < tq; ++q) {
  306.                 // 乘积元素在Q中的列号
  307.                 ccol = N.data[q].j;
  309.                 // 累加乘积
  310.                 ctemp[ccol] += M.data[p].e * N.data[q].e;
  311.             }
  312.         }
  314.         /*
  315.          * 至此，Q中第arow行元素已求出
  316.          */
  318.         // 遍历计算后的乘积，选取非零元存入Q中
  319.         for(ccol = 1; ccol <= (*Q).nu; ++ccol) {
  320.             // 若Q中第arow行ccol列元素不为0
  321.             if(ctemp[ccol]) {
  322.                 ++(*Q).tu;
  324.                 // 非零元个数超出限制
  325.                 if((*Q).tu > MAXSIZE) {
  326.                     return ERROR;
  327.                 }
  329.                 (*Q).data[(*Q).tu].i = arow;
  330.                 (*Q).data[(*Q).tu].j = ccol;
  331.                 (*Q).data[(*Q).tu].e = ctemp[ccol];
  332.             }
  333.         }
  334.     }
  336.     // 为rpos数组赋值
  337.     AssignRpos(Q);
  339.     return OK;
  340. }
  342. /*
  343.  * 矩阵转置
  344.  */
  345. Status TransposeSMatrix(RLSMatrix M, RLSMatrix* T) {
  346.     int p, q, col;
  348.     (*T).mu = M.nu;
  349.     (*T).nu = M.mu;
  350.     (*T).tu = M.tu;
  352.     if((*T).tu) {
  353.         q = 1;  // q用于T中非零元的计数
  355.         // col代表M的列，T的行
  356.         for(col = 1; col <= M.nu; ++col) {
  357.             // 在M中查找第j列的元素，依次将其转置到T中
  358.             for(p = 1; p <= M.tu; ++p) {
  359.                 if(M.data[p].j == col) {
  360.                     (*T).data[q].i = M.data[p].j;     // M的列变为T的行
  361.                     (*T).data[q].j = M.data[p].i;     // M的行变为T的列
  362.                     (*T).data[q].e = M.data[p].e;     // 每个三元组值不变
  364.                     ++q;
  365.                 }
  366.             }
  367.         }
  368.     }
  370.     // 为rpos数组赋值
  371.     AssignRpos(T);
  373.     return OK;
  374. }
  376. /*
  377.  * 矩阵快速转置
  378.  */
  379. Status FastTransposeSMatrix(RLSMatrix M, RLSMatrix* T) {
  380.     int col, t, p, q;
  381.     int* num;      // num[col] 表示M第col列中非零元的个数
  382.     int* copt;     // copt[col]表示M第col列第一个非零元在转置后矩阵中的位置
  384.     (*T).mu = M.nu;
  385.     (*T).nu = M.mu;
  386.     (*T).tu = M.tu;
  388.     // 提前返回
  389.     if((*T).tu == 0) {
  390.         return ERROR;
  391.     }
  393.     num  = (int*) malloc((M.nu + 1) * sizeof(int));
  394.     copt = (int*) malloc((M.nu + 1) * sizeof(int));
  396.     // 初始化数组num
  397.     for(col = 1; col <= M.nu; ++col) {
  398.         num[col] = 0;
  399.     }
  401.     // 统计M中的非零元，统计每列非零元的个数
  402.     for(t = 1; t <= M.tu; ++t) {
  403.         num[M.data[t].j]++;
  404.     }
  406.     // 第1列第1个非零元总是位于转置后矩阵中的首位
  407.     copt[1] = 1;
  408.     // 计算各列第1个非零元在转置矩阵中的位置
  409.     for(col = 2; col <= M.nu; ++col) {
  410.         copt[col] = copt[col - 1] + num[col - 1];
  411.     }
  413.     // 依次扫描M中的三元组
  414.     for(p = 1; p <= M.tu; ++p) {
  415.         col = M.data[p].j;              // 计算当前非零元所处的列
  416.         q = copt[col];                  // 计算当前非零元在转置矩阵中的位置
  417.         (*T).data[q].i = M.data[p].j;
  418.         (*T).data[q].j = M.data[p].i;
  419.         (*T).data[q].e = M.data[p].e;
  420.         ++copt[col];                    // 再遇到此列元素时，其在转置矩阵中的位置应当增一（该步骤很重要）
  421.     }
  423.     // 为rpos数组赋值
  424.     AssignRpos(T);
  426.     return OK;
  427. }
  429. /*
  430.  * 输出矩阵
  431.  */
  432. void PrintSMatrix(RLSMatrix M) {
  433.     int r, c;
  434.     int k = 1;
  436.     for(r = 1; r <= M.mu; ++r) {
  437.         for(c = 1; c <= M.nu; ++c) {
  438.             if(r == M.data[k].i && c == M.data[k].j) {
  439.                 printf("%3d ", M.data[k].e);
  440.                 k++;
  441.             } else {
  442.                 printf("%3d ", 0);
  443.             }
  444.         }
  445.         printf("\n");
  446.     }
  448.     printf("rpos = ");
  449.     for(k = 1; k <= M.mu; ++k) {
  450.         printf("%d ", M.rpos[k]);
  451.     }
  452.     printf("\n");
  453. }
  455. // 为rpos数组赋值
  456. static void AssignRpos(RLSMatrix* M) {
  457.     int k, m;
  459.     // 初始化数组rpos
  460.     for(k = 0; k <= MAXRC; ++k) {
  461.         (*M).rpos[k] = 0;
  462.     }
  464.     for(k = 1; k <= (*M).tu; k++) {
  465.         m = (*M).data[k].i;     // 当前三元组元素在矩阵中的行位置
  467.         // 记录每行第一个非零元的在三元组表中的位置
  468.         if((*M).rpos[m] == 0) {
  469.             (*M).rpos[m] = k;   // 只会在当前行有非零元的情况下记录
  470.         }
  471.     }
  473.     // 处理那些没有非零元的行
  474.     for(k = (*M).mu; k >= 1; k--) {
  475.         // 如果当前行没有非零元，则此处会直接取用下一行的参数
  476.         if((*M).rpos[k] == 0) {
  477.             // 如果是最后一行无非零元，因为已经不存在下一行了，所以需特殊处理
  478.             if(k == (*M).mu) {
  479.                 (*M).rpos[k] = (*M).tu + 1;
  480.             } else {
  481.                 (*M).rpos[k] = (*M).rpos[k + 1];
  482.             }
  483.         }
  484.     }
  485. }
  1. /* 非零元类型定义 */
  2. typedef struct OLNode {
  3.     int i, j;               // 该非零元的行下标和列下标
  4.     ElemType e;
  5.     struct OLNode* right;   // 该非零元所在的行表的后继链域
  6.     struct OLNode* down;    // 该非零元所在的列表的后继链域
  7. } OLNode, * OLink;
  9. /* 十字链表类型定义 */
  10. typedef struct {
  11.     OLink* rhead;       // 行链表头指针
  12.     OLink* chead;       // 列链表头指针
  13.     int mu, nu, tu;     // 矩阵的行数、列数和非零元个数
  14. } CrossList;
  16. /*
  17.  * ████████ 算法5.4 ████████
  18.  *
  19.  * 创建稀疏矩阵M
  20.  *
  21.  *
  22.  *【备注】
  23.  *
  24.  * 教材中默认从控制台读取数据。
  25.  * 这里为了方便测试，避免每次运行都手动输入数据，
  26.  * 因而允许选择从预设的文件path中读取测试数据。
  27.  *
  28.  * 如果需要从控制台读取数据，则path为NULL或者为空串，
  29.  * 如果需要从文件中读取数据，则需要在path中填写文件名信息。
  30.  */
  31. Status CreateSMatrix(CrossList* M, char* path) {
  32.     int i, j, k;
  33.     OLNode* p, * q;
  34.     FILE* fp;
  35.     int readFromConsole;    // 是否从控制台读取数据
  37.     // 如果没有文件路径信息，则从控制台读取输入
  38.     readFromConsole = path == NULL || strcmp(path, "") == 0;
  40.     if(readFromConsole) {
  41.         printf("请输入行数：");
  42.         scanf("%d", &((*M).mu));
  43.         printf("请输入列数：");
  44.         scanf("%d", &((*M).nu));
  45.         printf("请输入非零元素个数：");
  46.         scanf("%d", &((*M).tu));
  47.         printf("请输入%d个三元组信息\n", (*M).tu);
  48.     } else {
  49.         fp = fopen(path, "r");
  50.         ReadData(fp, "%d%d%d", &((*M).mu), &((*M).nu), &((*M).tu));
  51.     }
  53.     // 创建行链（类似行索引，0号单元弃用）
  54.     (*M).rhead = (OLink*) malloc(((*M).mu + 1) * sizeof(OLink));
  55.     if((*M).rhead == NULL) {
  56.         exit(OVERFLOW);
  57.     }
  59.     // 创建列链（类似列索引，0号单元弃用）
  60.     (*M).chead = (OLink*) malloc(((*M).nu + 1) * sizeof(OLink));
  61.     if((*M).chead == NULL) {
  62.         exit(OVERFLOW);
  63.     }
  65.     // 初始化行链索引为NULL
  66.     for(k = 0; k <= (*M).mu; ++k) {
  67.         (*M).rhead[k] = NULL;
  68.     }
  70.     // 初始化列链索引为NULL
  71.     for(k = 0; k <= (*M).nu; ++k) {
  72.         (*M).chead[k] = NULL;
  73.     }
  75.     // 依次录入非零元
  76.     for(k = 1; k <= (*M).tu; ++k) {
  77.         // 创建三元组结点
  78.         p = (OLNode*) malloc(sizeof(OLNode));
  79.         if(p == NULL) {
  80.             exit(OVERFLOW);
  81.         }
  83.         if(readFromConsole) {
  84.             printf("第%2d组：", k);
  85.             scanf("%d%d%d", &i, &j, &(p->e));
  86.         } else {
  87.             ReadData(fp, "%d%d%d", &i, &j, &(p->e));
  88.         }
  90.         p->i = i;   // 行号
  91.         p->j = j;   // 列号
  92.         p->right = p->down = NULL;
  94.         /*
  95.          * 开始行的插入
  96.          */
  98.         // 如果该行还没有元素，或已有元素均位于该元素右侧，则可以直接插入
  99.         if((*M).rhead[i] == NULL || (*M).rhead[i]->j > j) {
  100.             // 定位行表中的插入位置
  101.             p->right = (*M).rhead[i];
  102.             (*M).rhead[i] = p;
  103.         } else {
  104.             // 寻找插入位置的前一个位置
  105.             for(q = (*M).rhead[i]; (q->right) && (q->right->j < j); q = q->right) {
  106.             }
  108.             if(q->j == p->j || ((q->right) && q->right->j == p->j)) {
  109.                 printf("此位置已被占用！！\n");
  110.                 exit(ERROR);
  111.             }
  113.             p->right = q->right;
  114.             q->right = p;
  115.         }
  117.         /*
  118.          * 开始列的插入
  119.          */
  121.         // 如果该列还没有元素，或已有元素均位于该元素下侧，则可以直接插入
  122.         if((*M).chead[j] == NULL || (*M).chead[j]->i > i) {
  123.             // 定位列表中的插入位置
  124.             p->down = (*M).chead[j];
  125.             (*M).chead[j] = p;
  126.         } else {
  127.             // 寻找插入位置的前一个位置
  128.             for(q = (*M).chead[j]; (q->down) && (q->down->i < i); q = q->down) {
  129.             }
  131.             if(q->i == p->i || ((q->down) && q->down->i == p->i)) {
  132.                 printf("此位置已被占用！！\n");
  133.                 exit(ERROR);
  134.             }
  136.             p->down = q->down;
  137.             q->down = p;
  138.         }
  139.     }
  141.     if(!readFromConsole) {
  142.         fclose(fp);
  143.     }
  145.     return OK;
  146. }
  148. /*
  149.  * 矩阵复制
  150.  *
  151.  * 创建一个新矩阵T，该矩阵包含了从矩阵M中包含的数据。
  152.  */
  153. Status CopySMatrix(CrossList M, CrossList* T) {
  154.     int k;
  155.     OLNode* p, * q, * r, * l;
  157.     if(T == NULL) {
  158.         return ERROR;
  159.     }
  161.     // 复制行列信息
  162.     (*T).mu = M.mu;
  163.     (*T).nu = M.nu;
  164.     (*T).tu = M.tu;
  166.     // 创建行链（类似行索引，0号单元弃用）
  167.     (*T).rhead = (OLink*) malloc(((*T).mu + 1) * sizeof(OLink));
  168.     if((*T).rhead == NULL) {
  169.         exit(OVERFLOW);
  170.     }
  172.     // 创建列链（类似列索引，0号单元弃用）
  173.     (*T).chead = (OLink*) malloc(((*T).nu + 1) * sizeof(OLink));
  174.     if((*T).chead == NULL) {
  175.         exit(OVERFLOW);
  176.     }
  178.     // 初始化行链索引为NULL
  179.     for(k = 0; k <= (*T).mu; ++k) {                                //初始化行列头指针向量为空
  180.         (*T).rhead[k] = NULL;
  181.     }
  183.     // 初始化列链索引为NULL
  184.     for(k = 0; k <= (*T).nu; ++k) {
  185.         (*T).chead[k] = NULL;
  186.     }
  188.     // 按行扫描，依次复制非零元
  189.     for(k = 1; k <= M.mu; ++k) {
  190.         q = M.rhead[k];
  192.         // 如果当前行没有元素，直接跳过
  193.         if(q == NULL) {
  194.             continue;
  195.         }
  197.         r = NULL;
  199.         while(q != NULL) {
  200.             // 创建三元组结点
  201.             p = (OLNode*) malloc(sizeof(OLNode));
  202.             if(p == NULL) {
  203.                 exit(OVERFLOW);
  204.             }
  206.             // 为结点赋值
  207.             p->i = q->i;
  208.             p->j = q->j;
  209.             p->e = q->e;
  210.             p->right = p->down = NULL;
  212.             /*
  213.              * 开始行的插入
  214.              */
  216.             if(r == NULL) {
  217.                 (*T).rhead[q->i] = p;
  218.             } else {
  219.                 r->right = p;
  220.             }
  222.             // r指向当前行新插入的结点
  223.             r = p;
  225.             /*
  226.              * 开始列的插入
  227.              */
  229.             // 在列链中寻找插入位置
  230.             if((*T).chead[q->j] == NULL || (*T).chead[q->j]->i > q->i) {
  231.                 r->down = (*T).chead[q->j];
  232.                 (*T).chead[q->j] = r;
  233.             } else {
  234.                 // 寻找插入位置的前一个位置
  235.                 for(l = (*T).chead[q->j]; (l->down) && (l->down->i < q->i); l = l->down) {
  236.                 }
  237.                 r->down = l->down;
  238.                 l->down = r;
  239.             }
  241.             q = q->right;
  242.         }
  243.     }
  245.     return OK;
  246. }
  248. /*
  249.  * 矩阵加法
  250.  *
  251.  * Q = M + N。
  252.  */
  253. Status AddSMatrix(CrossList M, CrossList N, CrossList* Q) {
  254.     int i;
  255.     OLNode* pm, * pn, * p, * r, * l;
  257.     if(M.mu != N.mu || M.nu != N.nu) {
  258.         printf("两矩阵的行数、列数不满足相加条件！！\n");
  259.         return ERROR;
  260.     }
  262.     // 初始化Q的行列信息
  263.     Q->mu = M.mu;
  264.     Q->nu = M.nu;
  265.     Q->tu = 0;
  267.     // 创建行链（类似行索引，0号单元弃用）
  268.     Q->rhead = (OLink*) malloc((Q->mu + 1) * sizeof(OLink));
  269.     if(!Q->rhead) {
  270.         exit(OVERFLOW);
  271.     }
  273.     // 创建列链（类似列索引，0号单元弃用）
  274.     Q->chead = (OLink*) malloc((Q->nu + 1) * sizeof(OLink));
  275.     if(!Q->chead) {
  276.         exit(OVERFLOW);
  277.     }
  279.     // 初始化行链索引为NULL
  280.     for(i = 0; i <= Q->mu; ++i) {
  281.         Q->rhead[i] = NULL;
  282.     }
  284.     // 初始化列链索引为NULL
  285.     for(i = 0; i <= Q->nu; ++i) {
  286.         Q->chead[i] = NULL;
  287.     }
  289.     // 从第一行往下遍历
  290.     for(i = 1; i <= M.mu; ++i) {
  291.         pm = M.rhead[i];
  292.         pn = N.rhead[i];
  294.         // 如果M与N的当前行中均有未处理的非零元
  295.         while(pm != NULL && pn != NULL) {
  296.             // 处理特殊情形
  297.             if(pm->j == pn->j && pm->e + pn->e == 0) {
  298.                 pm = pm->right;
  299.                 pn = pn->right;
  300.                 continue;
  301.             }
  303.             // 创建结点
  304.             p = (OLNode*) malloc(sizeof(OLNode));
  305.             if(!p) {
  306.                 exit(OVERFLOW);
  307.             }
  309.             // M中的三元组列下标较小
  310.             if(pm->j < pn->j) {
  311.                 p->i = pm->i;
  312.                 p->j = pm->j;
  313.                 p->e = pm->e;
  314.                 pm = pm->right;
  316.                 // N中的三元组列下标较小
  317.             } else if(pm->j > pn->j) {
  318.                 p->i = pn->i;
  319.                 p->j = pn->j;
  320.                 p->e = pn->e;
  321.                 pn = pn->right;
  323.                 // M与N中的三元组列下标一致，需要进行加法运算
  324.             } else {
  325.                 p->i = pm->i;
  326.                 p->j = pm->j;
  327.                 p->e = pm->e + pn->e;
  328.                 pm = pm->right;
  329.                 pn = pn->right;
  330.             }
  332.             p->right = p->down = NULL;
  334.             Q->tu++;    // Q中非零元个数增一
  336.             /*
  337.              * 开始行的插入
  338.              */
  340.             if(Q->rhead[p->i] == NULL) {
  341.                 Q->rhead[p->i] = p;
  342.             } else {
  343.                 r->right = p;
  344.             }
  346.             // r指向当前行新插入的结点
  347.             r = p;
  349.             /*
  350.              * 开始列的插入
  351.              */
  353.             // 在列链中寻找插入位置
  354.             if(Q->chead[p->j] == NULL || Q->chead[p->j]->i > p->i) {
  355.                 r->down = Q->chead[p->j];
  356.                 Q->chead[p->j] = r;
  357.             } else {
  358.                 // 寻找插入位置的前一个位置
  359.                 for(l = Q->chead[p->j]; (l->down) && (l->down->i < p->i); l = l->down) {
  360.                 }
  361.                 r->down = l->down;
  362.                 l->down = r;
  363.             }
  364.         }
  366.         // 如果M的当前行中仍有未处理的非零元
  367.         while(pm != NULL) {
  368.             p = (OLNode*) malloc(sizeof(OLNode));
  369.             if(p == NULL) {
  370.                 exit(OVERFLOW);
  371.             }
  372.             p->i = pm->i;
  373.             p->j = pm->j;
  374.             p->e = pm->e;
  375.             p->right = p->down = NULL;
  377.             Q->tu++;    // Q中非零元个数增一
  379.             if(Q->rhead[p->i] == NULL) {
  380.                 Q->rhead[p->i] = p;
  381.             } else {
  382.                 r->right = p;
  383.             }
  385.             // r指向当前行新插入的结点
  386.             r = p;
  388.             // 在列链中寻找插入位置
  389.             if(Q->chead[p->j] == NULL || Q->chead[p->j]->i > p->i) {
  390.                 r->down = Q->chead[p->j];
  391.                 Q->chead[p->j] = r;
  392.             } else {
  393.                 // 寻找插入位置的前一个位置
  394.                 for(l = Q->chead[p->j]; (l->down) && (l->down->i < p->i); l = l->down) {
  395.                 }
  396.                 r->down = l->down;
  397.                 l->down = r;
  398.             }
  400.             pm = pm->right;
  401.         }
  403.         // 如果N的当前行中仍有未处理的非零元
  404.         while(pn != NULL) {
  405.             p = (OLNode*) malloc(sizeof(OLNode));
  406.             if(p == NULL) {
  407.                 exit(OVERFLOW);
  408.             }
  409.             p->i = pn->i;
  410.             p->j = pn->j;
  411.             p->e = pn->e;
  412.             p->right = p->down = NULL;
  414.             Q->tu++;    // Q中非零元个数增一
  416.             if(Q->rhead[p->i] == NULL) {
  417.                 Q->rhead[p->i] = p;
  418.             } else {
  419.                 r->right = p;
  420.             }
  422.             // r指向当前行新插入的结点
  423.             r = p;
  425.             // 在列链中寻找插入位置
  426.             if(Q->chead[p->j] == NULL || Q->chead[p->j]->i > p->i) {
  427.                 r->down = Q->chead[p->j];
  428.                 Q->chead[p->j] = r;
  429.             } else {
  430.                 // 寻找插入位置的前一个位置
  431.                 for(l = Q->chead[p->j]; (l->down) && (l->down->i < p->i); l = l->down) {
  432.                 }
  433.                 r->down = l->down;
  434.                 l->down = r;
  435.             }
  437.             pn = pn->right;
  438.         }
  439.     }
  441.     return OK;
  442. }
  444. /*
  445.  * 矩阵减法
  446.  *
  447.  * Q = M - N。
  448.  */
  449. Status SubSMatrix(CrossList M, CrossList N, CrossList* Q) {
  450.     int i;
  451.     OLNode* pm, * pn, * p, * r, * l;
  453.     if(M.mu != N.mu || M.nu != N.nu) {
  454.         printf("两矩阵的行数、列数不满足相减条件！！\n");
  455.         return ERROR;
  456.     }
  458.     // 初始化Q的行列信息
  459.     Q->mu = M.mu;
  460.     Q->nu = M.nu;
  461.     Q->tu = 0;
  463.     // 创建行链（类似行索引，0号单元弃用）
  464.     Q->rhead = (OLink*) malloc((Q->mu + 1) * sizeof(OLink));
  465.     if(!Q->rhead) {
  466.         exit(OVERFLOW);
  467.     }
  469.     // 创建列链（类似列索引，0号单元弃用）
  470.     Q->chead = (OLink*) malloc((Q->nu + 1) * sizeof(OLink));
  471.     if(!Q->chead) {
  472.         exit(OVERFLOW);
  473.     }
  475.     // 初始化行链索引为NULL
  476.     for(i = 0; i <= Q->mu; ++i) {
  477.         Q->rhead[i] = NULL;
  478.     }
  480.     // 初始化列链索引为NULL
  481.     for(i = 0; i <= Q->nu; ++i) {
  482.         Q->chead[i] = NULL;
  483.     }
  485.     // 从第一行往下遍历
  486.     for(i = 1; i <= M.mu; ++i) {
  487.         pm = M.rhead[i];
  488.         pn = N.rhead[i];
  490.         // 如果M与N的当前行中均有未处理的非零元
  491.         while(pm != NULL && pn != NULL) {
  492.             // 处理特殊情形
  493.             if(pm->j == pn->j && pm->e - pn->e == 0) {
  494.                 pm = pm->right;
  495.                 pn = pn->right;
  496.                 continue;
  497.             }
  499.             // 创建结点
  500.             p = (OLNode*) malloc(sizeof(OLNode));
  501.             if(!p) {
  502.                 exit(OVERFLOW);
  503.             }
  505.             // M中的三元组列下标较小
  506.             if(pm->j < pn->j) {
  507.                 p->i = pm->i;
  508.                 p->j = pm->j;
  509.                 p->e = pm->e;
  510.                 pm = pm->right;
  512.                 // N中的三元组列下标较小
  513.             } else if(pm->j > pn->j) {
  514.                 p->i = pn->i;
  515.                 p->j = pn->j;
  516.                 p->e = -pn->e;      // 加负号
  517.                 pn = pn->right;
  519.                 // M与N中的三元组列下标一致，需要进行减法运算
  520.             } else {
  521.                 p->i = pm->i;
  522.                 p->j = pm->j;
  523.                 p->e = pm->e - pn->e;
  524.                 pm = pm->right;
  525.                 pn = pn->right;
  526.             }
  528.             p->right = p->down = NULL;
  530.             Q->tu++;    // Q中非零元个数增一
  532.             /*
  533.              * 开始行的插入
  534.              */
  536.             if(Q->rhead[p->i] == NULL) {
  537.                 Q->rhead[p->i] = p;
  538.             } else {
  539.                 r->right = p;
  540.             }
  542.             // r指向当前行新插入的结点
  543.             r = p;
  545.             /*
  546.              * 开始列的插入
  547.              */
  549.             // 在列链中寻找插入位置
  550.             if(Q->chead[p->j] == NULL || Q->chead[p->j]->i > p->i) {
  551.                 r->down = Q->chead[p->j];
  552.                 Q->chead[p->j] = r;
  553.             } else {
  554.                 //寻找插入位置的前一个位置
  555.                 for(l = Q->chead[p->j]; (l->down) && (l->down->i < p->i); l = l->down) {
  556.                 }
  557.                 r->down = l->down;
  558.                 l->down = r;
  559.             }
  560.         }
  562.         // 如果M的当前行中仍有未处理的非零元
  563.         while(pm != NULL) {
  564.             p = (OLNode*) malloc(sizeof(OLNode));
  565.             if(!p) {
  566.                 exit(OVERFLOW);
  567.             }
  568.             p->i = pm->i;
  569.             p->j = pm->j;
  570.             p->e = pm->e;
  571.             p->right = p->down = NULL;
  573.             Q->tu++;    // Q中非零元个数增一
  575.             if(Q->rhead[p->i] == NULL) {
  576.                 Q->rhead[p->i] = p;
  577.             } else {
  578.                 r->right = p;
  579.             }
  581.             // r指向当前行新插入的结点
  582.             r = p;
  584.             // 在列链中寻找插入位置
  585.             if(Q->chead[p->j] == NULL || Q->chead[p->j]->i > p->i) {
  586.                 r->down = Q->chead[p->j];
  587.                 Q->chead[p->j] = r;
  588.             } else {
  589.                 // 寻找插入位置的前一个位置
  590.                 for(l = Q->chead[p->j]; (l->down) && (l->down->i < p->i); l = l->down) {
  591.                 }
  592.                 r->down = l->down;
  593.                 l->down = r;
  594.             }
  596.             pm = pm->right;
  597.         }
  599.         // 如果N的当前行中仍有未处理的非零元
  600.         while(pn != NULL) {
  601.             p = (OLNode*) malloc(sizeof(OLNode));
  602.             if(!p) {
  603.                 exit(OVERFLOW);
  604.             }
  605.             p->i = pn->i;
  606.             p->j = pn->j;
  607.             p->e = -pn->e;              // 加负号
  608.             p->right = p->down = NULL;
  610.             Q->tu++;    // Q中非零元个数增一
  612.             if(Q->rhead[p->i] == NULL) {
  613.                 Q->rhead[p->i] = p;
  614.             } else {
  615.                 r->right = p;
  616.             }
  618.             // r指向当前行新插入的结点
  619.             r = p;
  621.             // 在列链中寻找插入位置
  622.             if(Q->chead[p->j] == NULL || Q->chead[p->j]->i > p->i) {
  623.                 r->down = Q->chead[p->j];
  624.                 Q->chead[p->j] = r;
  625.             } else {
  626.                 // 寻找插入位置的前一个位置
  627.                 for(l = Q->chead[p->j]; (l->down) && (l->down->i < p->i); l = l->down) {
  628.                 }
  629.                 r->down = l->down;
  630.                 l->down = r;
  631.             }
  633.             pn = pn->right;
  634.         }
  635.     }
  637.     return OK;
  638. }
  640. /*
  641.  * 矩阵乘法
  642.  *
  643.  * Q = M * N。
  644.  */
  645. Status MultSMatrix(CrossList M, CrossList N, CrossList* Q) {
  646.     int m_row, n_col, i;
  647.     ElemType e;
  648.     OLNode* pm, * pn, * p, * r, * l;
  650.     // M的列数需要等于N的行数
  651.     if(M.nu != N.mu) {
  652.         printf("两矩阵的行数、列数不满足相乘条件！！\n");
  653.         return ERROR;
  654.     }
  656.     // 初始化Q的行列信息
  657.     Q->mu = M.mu;
  658.     Q->nu = N.nu;
  659.     Q->tu = 0;
  661.     // 创建行链（类似行索引，0号单元弃用）
  662.     Q->rhead = (OLink*) malloc((Q->mu + 1) * sizeof(OLink));
  663.     if(!Q->rhead) {
  664.         exit(OVERFLOW);
  665.     }
  667.     // 创建列链（类似列索引，0号单元弃用）
  668.     Q->chead = (OLink*) malloc((Q->nu + 1) * sizeof(OLink));
  669.     if(!Q->chead) {
  670.         exit(OVERFLOW);
  671.     }
  673.     // 初始化行链索引为NULL
  674.     for(i = 0; i <= Q->mu; ++i) {
  675.         Q->rhead[i] = NULL;
  676.     }
  678.     // 初始化列链索引为NULL
  679.     for(i = 0; i <= Q->nu; ++i) {
  680.         Q->chead[i] = NULL;
  681.     }
  683.     // Q是非零矩阵
  684.     if(M.tu * N.tu) {
  685.         for(m_row = 1; m_row <= M.mu; ++m_row) {
  686.             for(n_col = 1; n_col <= N.nu; ++n_col) {
  687.                 pm = M.rhead[m_row];
  688.                 pn = N.chead[n_col];
  690.                 e = 0;
  692.                 // M的行与N的列相乘
  693.                 while(pm && pn) {
  694.                     if(pm->j < pn->i) {
  695.                         pm = pm->right;
  696.                     } else if(pm->j > pn->i) {
  697.                         pn = pn->down;
  698.                     } else {
  699.                         e += pm->e * pn->e;
  700.                         pm = pm->right;
  701.                         pn = pn->down;
  702.                     }
  703.                 }
  705.                 if(e == 0) {
  706.                     continue;
  707.                 }
  709.                 p = (OLNode*) malloc(sizeof(OLNode));
  710.                 if(!p) {
  711.                     exit(OVERFLOW);
  712.                 }
  714.                 // 为结点赋值
  715.                 p->i = M.rhead[m_row]->i;
  716.                 p->j = N.chead[n_col]->j;
  717.                 p->e = e;
  718.                 p->right = p->down = NULL;
  720.                 Q->tu++;    // Q中非零元个数增一
  722.                 if(Q->rhead[p->i] == NULL) {
  723.                     Q->rhead[p->i] = p;
  724.                 } else {
  725.                     r->right = p;
  726.                 }
  728.                 // r指向当前行新插入的结点
  729.                 r = p;
  731.                 // 在列链中寻找插入位置
  732.                 if(Q->chead[p->j] == NULL || Q->chead[p->j]->i > p->i) {
  733.                     r->down = Q->chead[p->j];
  734.                     Q->chead[p->j] = r;
  735.                 } else {
  736.                     // 寻找插入位置的前一个位置
  737.                     for(l = Q->chead[p->j]; (l->down) && (l->down->i < p->i); l = l->down) {
  738.                     }
  740.                     r->down = l->down;
  741.                     l->down = r;
  742.                 }
  743.             }
  744.         }
  745.     }
  747.     return OK;
  748. }
  750. /*
  751.  * 矩阵转置
  752.  */
  753. Status TransposeSMatrix(CrossList M, CrossList* T) {
  754.     int i;
  755.     OLNode* p, * q, * r, * l;
  757.     // 初始化Q的行列信息
  758.     (*T).mu = M.nu;
  759.     (*T).nu = M.mu;
  760.     (*T).tu = M.tu;
  762.     // 创建行链（类似行索引，0号单元弃用）
  763.     (*T).rhead = (OLink*) malloc(((*T).mu + 1) * sizeof(OLink));
  764.     if(!(*T).rhead) {
  765.         exit(OVERFLOW);
  766.     }
  768.     // 创建列链（类似列索引，0号单元弃用）
  769.     (*T).chead = (OLink*) malloc(((*T).nu + 1) * sizeof(OLink));
  770.     if(!(*T).chead) {
  771.         exit(OVERFLOW);
  772.     }
  774.     // 初始化行链索引为NULL
  775.     for(i = 0; i <= (*T).mu; ++i) {
  776.         (*T).rhead[i] = NULL;
  777.     }
  779.     // 初始化列链索引为NULL
  780.     for(i = 0; i <= (*T).nu; ++i) {
  781.         (*T).chead[i] = NULL;
  782.     }
  784.     // 零矩阵
  785.     if(!(*T).tu) {
  786.         return OK;
  787.     }
  789.     // 按列扫描
  790.     for(i = 1; i <= M.nu; ++i) {
  791.         q = M.chead[i];
  793.         // 如果当前行没有元素，直接跳过
  794.         if(q == NULL) {
  795.             continue;
  796.         }
  798.         while(q != NULL) {
  799.             // 创建三元组结点
  800.             p = (OLNode*) malloc(sizeof(OLNode));
  801.             if(!p) {
  802.                 exit(OVERFLOW);
  803.             }
  805.             // 为结点赋值，行变列，列变行
  806.             p->i = q->j;
  807.             p->j = q->i;
  808.             p->e = q->e;
  809.             p->right = p->down = NULL;
  811.             /*
  812.              * 开始行的插入
  813.              */
  815.             if((*T).rhead[p->i] == NULL) {
  816.                 (*T).rhead[p->i] = p;
  817.             } else {
  818.                 r->right = p;
  819.             }
  821.             // r指向当前行新插入的结点
  822.             r = p;
  824.             /*
  825.              * 开始列的插入
  826.              */
  828.             // 在列链中寻找插入位置
  829.             if((*T).chead[p->j] == NULL || (*T).chead[p->j]->i > p->i) {
  830.                 r->down = (*T).chead[p->j];
  831.                 (*T).chead[p->j] = r;
  832.             } else {
  833.                 // 寻找插入位置的前一个位置
  834.                 for(l = (*T).chead[p->j]; (l->down) && (l->down->i < p->i); l = l->down) {
  835.                 }
  836.                 r->down = l->down;
  837.                 l->down = r;
  838.             }
  840.             q = q->down;
  841.         }
  842.     }
  844.     return OK;
  845. }
  847. /*
  848.  * 输出矩阵
  849.  */
  850. void PrintSMatrix(CrossList M) {
  851.     int i, j;
  852.     OLNode* p;
  854.     for(i = 1; i <= M.mu; ++i) {
  855.         p = M.rhead[i];
  856.         for(j = 1; j <= M.nu; ++j) {
  857.             if(p && p->j == j) {
  858.                 printf("%3d ", p->e);
  859.                 p = p->right;
  860.             } else {
  861.                 printf("%3d ", 0);
  862.             }
  863.         }
  864.         printf("\n");
  865.     }
  866. }

广义表的定义（深度、长度）

  1. /* 广义表（头尾链表存储表示）类型定义 */
  2. typedef struct GLNode {
  3.     ElemTag tag;    // 公共标记，用于区分原子结点和表结点
  5.     // 原子结点和表结点的联合部分
  6.     union {
  7.         AtomType atom;          // atom是原子结点的值域，AtomType由用户定义
  8.         struct {
  9.             struct GLNode* hp;  // 指向表头
  10.             struct GLNode* tp;  // 指向表尾
  11.         } ptr;                  // 表结点的指针域
  12.     } Node;
  13. } GLNode;
  15. /*
  16.  * ████████ 算法5.7 ████████
  17.  *
  18.  * 创建
  19.  *
  20.  * 由字符串S创建广义表L。
  21.  */
  22. Status CreateGList(GList* L, SString S) {
  23.     SString emp;        // 代表空广义表的字符串
  24.     SString hsub, sub;
  25.     GList p, q;
  27.     if(L == NULL) {
  28.         return ERROR;
  29.     }
  31.     // 清理字符串S中的空白，包括清理不可打印字符和清理空格
  32.     ClearBlank(S);
  34.     if(StrEmpty(S)) {
  35.         return ERROR;
  36.     }
  38.     StrAssign(emp, "()");
  40.     /*
  41.      * 如果输入串为()，则代表需要创建空的广义表
  42.      *
  43.      *【注】
  44.      * 教材这里的代码是有问题的。
  45.      * StrCompare的返回值指示的是两个字符串的大小，而不是指示两个字符串是否相等。
  46.      * 如果给定的S与()相等，返回值应当是0。
  47.      */
  48.     if(!StrCompare(S, emp)) {
  49.         *L = NULL;
  50.     } else {
  51.         *L = (GList) malloc(sizeof(GLNode));
  52.         if(*L == NULL) {
  53.             exit(OVERFLOW);
  54.         }
  56.         // 创建原子
  57.         if(StrLength(S) == 1) {
  58.             (*L)->tag = Atom;
  59.             (*L)->Node.atom = S[1];
  60.         } else {
  61.             (*L)->tag = List;
  63.             p = *L;
  65.             // 去掉最外层括号
  66.             SubString(sub, S, 2, StrLength(S) - 2);
  68.             // 重复建n个子表
  69.             do {
  70.                 // 从sub中分离出表头串hsub，分离完成后，sub也会发生变化
  71.                 sever(hsub, sub);
  73.                 // 递归创建广义表
  74.                 CreateGList(&(p->Node.ptr.hp), hsub);
  76.                 q = p;
  78.                 // 如果表尾不为空，需要继续处理表尾
  79.                 if(!StrEmpty(sub)) {
  80.                     p = (GList) malloc(sizeof(GLNode));
  81.                     if(p == NULL) {
  82.                         exit(OVERFLOW);
  83.                     }
  85.                     p->tag = List;
  87.                     q->Node.ptr.tp = p;
  88.                 }
  89.             } while(!StrEmpty(sub));
  91.             q->Node.ptr.tp = NULL;
  92.         }
  93.     }
  95.     return OK;
  96. }
  98. /*
  99.  * ████████ 算法5.6 ████████
  100.  *
  101.  * 复制
  102.  *
  103.  * 由广义表L复制得到广义表T。
  104.  */
  105. Status CopyGList(GList* T, GList L) {
  106.     if(T == NULL) {
  107.         return ERROR;
  108.     }
  110.     if(L == NULL) {
  111.         *T = NULL;
  112.     } else {
  113.         // 新建广义表结点
  114.         *T = (GList) malloc(sizeof(GLNode));
  115.         if(*T == NULL) {
  116.             exit(OVERFLOW);
  117.         }
  119.         (*T)->tag = L->tag;
  121.         // 复制单原子
  122.         if(L->tag == Atom) {
  123.             (*T)->Node.atom = L->Node.atom;
  125.             // 复制表头和表尾
  126.         } else {
  127.             CopyGList(&((*T)->Node.ptr.hp), L->Node.ptr.hp);
  128.             CopyGList(&((*T)->Node.ptr.tp), L->Node.ptr.tp);
  129.         }
  130.     }
  132.     return OK;
  133. }
  135. /*
  136.  * ████████ 算法5.5 ████████
  137.  *
  138.  * 深度
  139.  *
  140.  * 返回广义表的深度
  141.  */
  142. int GListDepth(GList L) {
  143.     int max, deep;
  144.     GList p;
  146.     // 空表深度为1
  147.     if(L == NULL) {
  148.         return 1;
  149.     }
  151.     // 原子深度为0
  152.     if(L->tag == Atom) {
  153.         return 0;
  154.     }
  156.     // 递归求子表深度
  157.     for(max = 0, p = L; p != NULL; p = p->Node.ptr.tp) {
  158.         deep = GListDepth(p->Node.ptr.hp);
  159.         if(deep > max) {
  160.             max = deep;
  161.         }
  162.     }
  164.     // 非空表的深度是各子元素最大深度加一
  165.     return max + 1;
  166. }
  1. /* 广义表（扩展线性链表存储表示）类型定义 */
  2. typedef struct GLNode {
  3.     ElemTag tag;    // 公共标记，用于区分原子结点和表结点
  5.     // 原子结点和表结点的联合部分
  6.     union
  7.     {
  8.         AtomType atom;      // atom是原子结点的值域，AtomType由用户定义
  9.         struct GLNode* hp;  // 指向表头
  10.     } Node;
  11.     struct GLNode* tp;      // 指向表尾
  12. } GLNode;
  14. /*
  15.  * 创建
  16.  *
  17.  * 由字符串S创建广义表L。
  18.  */
  19. Status CreateGList(GList* L, SString S) {
  20.     SString emp, hsub, sub, tmp;
  22.     if(L == NULL) {
  23.         return ERROR;
  24.     }
  26.     // 清理字符串S中的空白，包括清理不可打印字符和清理空格
  27.     ClearBlank(S);
  29.     if(StrEmpty(S)) {
  30.         return ERROR;
  31.     }
  33.     // 复制是为了不破坏S
  34.     StrCopy(sub, S);
  36.     /*
  37.      * 初次执行到此时，带着最外层的括号
  38.      * 再次执行到此时，已经脱去了外层括号
  39.      */
  40.     sever(hsub, sub);
  42.     *L = (GList) malloc(sizeof(GLNode));
  43.     if(*L == NULL) {
  44.         exit(OVERFLOW);
  45.     }
  47.     StrAssign(emp, "()");
  49.     if(!StrCompare(hsub, emp)) {
  50.         (*L)->tag = List;
  51.         (*L)->Node.hp = NULL;
  52.     } else {
  53.         if(StrLength(hsub) == 1) {
  54.             (*L)->tag = Atom;
  55.             (*L)->Node.atom = hsub[1];
  56.         } else {
  57.             (*L)->tag = List;
  59.             SubString(tmp, hsub, 2, StrLength(hsub) - 2);
  61.             CreateGList(&((*L)->Node.hp), tmp);
  62.         }
  63.     }
  65.     // 如果不存在队尾，则退出本层递归
  66.     if(StrEmpty(sub)) {
  67.         (*L)->tp = NULL;
  68.     } else {
  69.         // 继续递归求表尾
  70.         CreateGList(&((*L)->tp), sub);
  71.     }
  73.     return OK;
  74. }
  76. /*
  77.  * 深度
  78.  *
  79.  * 返回广义表的深度
  80.  */
  81. int GListDepth(GList L) {
  82.     int max, deep;
  83.     GList p;
  85.     max = 0;
  87.     // 广义表不存在
  88.     if(L == NULL) {
  89.         return -1;
  90.     }
  92.     // 空表深度为1
  93.     if(L->tag == List && !L->Node.hp) {
  94.         return 1;
  95.     }
  97.     // 原子深度为0
  98.     if(L->tag == Atom) {
  99.         return 0;
  100.     }
  102.     // 递归求子表深度
  103.     for(p = L->Node.hp; p != NULL; p = p->tp) {
  104.         // 求以p为头指针的子表深度
  105.         deep = GListDepth(p);
  106.         if(deep > max) {
  107.             max = deep;
  108.         }
  109.     }
  111.     return max + 1;
  112. }

求表头Head、表尾Tail操作

  1. /*
  2.  * 表头
  3.  */
  4. GList GetHead(GList L) {
  5.     GList p;
  7.     // 空表无表头，这里不能返回NULL，不然分不清是失败了还是返回了空表
  8.     if(L == NULL) {
  9.         exit(ERROR);
  10.     }
  12.     CopyGList(&p, L->Node.ptr.hp);
  14.     return p;
  15. }
  17. /*
  18.  * 表尾
  19.  */
  20. GList GetTail(GList L) {
  21.     GList p;
  23.     // 空表无表尾，这里不能返回NULL，不然分不清是失败了还是返回了空表
  24.     if(L == NULL) {
  25.         exit(ERROR);
  26.     }
  28.     CopyGList(&p, L->Node.ptr.tp);
  30.     return p;
  31. }
  1. /*
  2.  * 表头
  3.  */
  4. GList GetHead(GList L) {
  5.     GList p, q;
  7.     // 广义表不存在或广义表为空表，无法获取表头
  8.     if(L == NULL || L->Node.hp == NULL) {
  9.         return NULL;
  10.     }
  12.     q = L->Node.hp->tp;         // 临时保存L的表尾信息
  13.     L->Node.hp->tp = NULL;      // 截去L的表尾部分
  15.     CopyGList(&p, L->Node.hp);  // 复制表头信息（已屏蔽表尾）
  17.     L->Node.hp->tp = q;         // 恢复L的表尾信息
  19.     return p;
  20. }
  22. /*
  23.  * 表尾
  24.  */
  25. GList GetTail(GList L) {
  26.     GList p, q;
  28.     // 广义表不存在或广义表为空表，无法获取表尾
  29.     if(L == NULL || L->Node.hp == NULL) {
  30.         return NULL;
  31.     }
  33.     q = L->Node.hp;         // 临时保存L的表头信息
  34.     L->Node.hp = q->tp;     // 摘下L的表头部分
  36.     CopyGList(&p, L);       // 复制表尾信息（已屏蔽表头）
  38.     q->tp = L->Node.hp;     // 恢复L的表头信息
  39.     L->Node.hp = q;
  41.     return p;
  42. }

第六章 树

树、二叉树的定义
树（tree）是n（n>=0）个节点的有限集合
1）有且仅有一个称为根的节点；
2）除根节点以外，其余节点可分为m（m＞0）个互不相交的有限集复习提要（20级） - 图32，其中每一个集合本身又是一棵树，并且称为根的子树（subtree）。

二叉树（binary tree）是n（n>=0）个节点构成的集合，它或为空树（n=0），或满足以下两个条件：
1）有且仅有一个称为根的节点；
2）除根节点以外，其余节点分为两个互不相交的子集T1和T2，分别称为T的左子树和右子树，且T1和T2本身都是二叉树。

二叉树的性质

  1. 非空二叉树上叶子结点数等于度为2的结点数加1
  2. 非空二叉树上第复习提要（20级） - 图33层上至多有复习提要（20级） - 图34个结点（K≥1）
  3. 深度度为复习提要（20级） - 图35的二叉树至多有复习提要（20级） - 图36个结点（H≥1）
  4. 具有复习提要（20级） - 图37个节点的完全二叉树的深度必为复习提要（20级） - 图38。复习提要（20级） - 图39

完全二叉树和满二叉树
满二叉树：一颗深度度为复习提要（20级） - 图40且有复习提要（20级） - 图41个结点的二叉树（H≥1）


  • 二叉树的三种遍历（先序、中序、后序） __*

先序DLR（根左右）
1）访问根节点；
2）先序遍历左子树；
3）先序遍历右子树。

中序LDR（左中右）
1）中序遍历左子树；
2）访问根节点；
3）中序遍历右子树。

后序LRD（左右中）
1）后序遍历左子树；
2）后序遍历右子树；
3）访问根节点。

  1. typedef TElemType SqBiTree[MAX_TREE_SIZE];
  3. // 先序遍历的内部实现
  4. static Status PreTraverse(SqBiTree T, Status(Visit)(TElemType), int i) {
  5.     // 越界
  6.     if(i >= MAX_TREE_SIZE) {
  7.         return ERROR;
  8.     }
  10.     if(T[i]) {
  11.         if(Visit(T[i])) {
  12.             if(PreTraverse(T, Visit, 2 * i + 1)) {
  13.                 if(PreTraverse(T, Visit, 2 * i + 2)) {
  14.                     return OK;
  15.                 }
  16.             }
  17.         }
  19.         return ERROR;
  21.         // 遇到空树则无需继续计算
  22.     } else {
  23.         return OK;
  24.     }
  25. }
  27. // 中序遍历的内部实现
  28. static Status InTraverse(SqBiTree T, Status(Visit)(TElemType), int i) {
  29.     // 越界
  30.     if(i >= MAX_TREE_SIZE) {
  31.         return ERROR;
  32.     }
  34.     if(T[i]) {
  35.         if(InTraverse(T, Visit, 2 * i + 1)) {
  36.             if(Visit(T[i])) {
  37.                 if(InTraverse(T, Visit, 2 * i + 2)) {
  38.                     return OK;
  39.                 }
  40.             }
  42.         }
  44.         return ERROR;
  46.         // 遇到空树则无需继续计算
  47.     } else {
  48.         return OK;
  49.     }
  50. }
  52. // 后序遍历的内部实现
  53. static Status PostTraverse(SqBiTree T, Status(Visit)(TElemType), int i) {
  54.     // 越界
  55.     if(i >= MAX_TREE_SIZE) {
  56.         return ERROR;
  57.     }
  59.     if(T[i]) {
  60.         if(PostTraverse(T, Visit, 2 * i + 1)) {
  61.             if(PostTraverse(T, Visit, 2 * i + 2)) {
  62.                 if(Visit(T[i])) {
  63.                     return OK;
  64.                 }
  66.             }
  67.         }
  69.         return ERROR;
  71.         // 遇到空树则无需继续计算
  72.     } else {
  73.         return OK;
  74.     }
  75. }
  1. /* 二叉树结点定义 */
  2. typedef struct BiTNode {
  3.     TElemType data;             // 结点元素
  4.     struct BiTNode* lchild;     // 左孩子指针
  5.     struct BiTNode* rchild;     // 右孩子指针
  6. } BiTNode;
  8. /*
  9.  * ████████ 算法6.4 ████████
  10.  *
  11.  * 创建
  12.  *
  13.  * 按照预设的定义来创建二叉树。
  14.  * 这里约定使用【先序序列】来创建二叉树。
  15.  *
  16.  *
  17.  *【备注】
  18.  *
  19.  * 教材中默认从控制台读取数据。
  20.  * 这里为了方便测试，避免每次运行都手动输入数据，
  21.  * 因而允许选择从预设的文件path中读取测试数据。
  22.  *
  23.  * 如果需要从控制台读取数据，则path为NULL或者为空串，
  24.  * 如果需要从文件中读取数据，则需要在path中填写文件名信息。
  25.  */
  26. Status CreateBiTree(BiTree* T, char* path) {
  27.     FILE* fp;
  28.     int readFromConsole;    // 是否从控制台读取数据
  30.     // 如果没有文件路径信息，则从控制台读取输入
  31.     readFromConsole = path == NULL || strcmp(path, "") == 0;
  33.     if(readFromConsole) {
  34.         printf("请输入二叉树的先序序列，如果没有子结点，使用^代替：");
  35.         CreateTree(T, NULL);
  36.     } else {
  37.         // 打开文件，准备读取测试数据
  38.         fp = fopen(path, "r");
  39.         if(fp == NULL) {
  40.             return ERROR;
  41.         }
  42.         CreateTree(T, fp);
  43.         fclose(fp);
  44.     }
  46.     return OK;
  47. }
  49. /*
  50.  * 判空
  51.  *
  52.  * 判断二叉树是否为空树。
  53.  */
  54. Status BiTreeEmpty(BiTree T) {
  55.     return T == NULL ? TRUE : FALSE;
  56. }
  58. /*
  59.  * 树深
  60.  *
  61.  * 返回二叉树的深度（层数）。
  62.  */
  63. int BiTreeDepth(BiTree T) {
  64.     int LD, RD;
  66.     if(T == NULL) {
  67.         return 0;                       // 空树深度为0
  68.     } else {
  69.         LD = BiTreeDepth(T->lchild);    // 求左子树深度
  70.         RD = BiTreeDepth(T->rchild);    // 求右子树深度
  72.         return (LD >= RD ? LD : RD) + 1;
  73.     }
  74. }
  76. /*
  77.  * 取值
  78.  *
  79.  * 返回二叉树中指定结点的值。
  80.  */
  81. TElemType Value(BiTree T, TElemType e) {
  82.     BiTree p;
  84.     // 遇到空树则无需继续计算
  85.     if(BiTreeEmpty(T)) {
  86.         return '\0';
  87.     }
  89.     // 获取结点e的指针
  90.     p = EPtr(T, e);
  92.     // 如果没有找到元素e
  93.     if(p == NULL) {
  94.         return '\0';
  95.     } else {
  96.         return p->data;
  97.     }
  98. }
  100. /*
  101.  * 赋值
  102.  *
  103.  * 为二叉树指定的结点赋值。
  104.  */
  105. Status Assign(BiTree T, TElemType e, TElemType value) {
  106.     BiTree p;
  108.     // 遇到空树则无需继续计算
  109.     if(BiTreeEmpty(T)) {
  110.         return ERROR;
  111.     }
  113.     // 获取结点e的指针
  114.     p = EPtr(T, e);
  116.     // 如果没有找到元素e
  117.     if(p == NULL) {
  118.         return ERROR;
  119.     } else {
  120.         // 进行赋值
  121.         p->data = value;
  122.         return OK;
  123.     }
  124. }
  126. /*
  127.  * 根
  128.  *
  129.  * 返回二叉树的根结点。
  130.  */
  131. TElemType Root(BiTree T) {
  132.     // 遇到空树则无需继续计算
  133.     if(BiTreeEmpty(T)) {
  134.         return '\0';
  135.     }
  137.     return T->data;
  138. }
  140. /*
  141.  * 双亲
  142.  *
  143.  * 返回二叉树中结点e的双亲结点。
  144.  */
  145. TElemType Parent(BiTree T, TElemType e) {
  146.     BiTree p;
  148.     // 遇到空树则无需继续计算
  149.     if(BiTreeEmpty(T)) {
  150.         return '\0';
  151.     }
  153.     // 获取结点e的双亲结点的指针
  154.     p = PPtr(T, e);
  156.     // 如果没有找到元素e的双亲
  157.     if(p == NULL) {
  158.         return '\0';
  159.     } else {
  160.         return p->data;
  161.     }
  162. }
  164. /*
  165.  * 左孩子
  166.  *
  167.  * 返回二叉树中结点e的左孩子结点。
  168.  */
  169. TElemType LeftChild(BiTree T, TElemType e) {
  170.     BiTree p;
  172.     // 遇到空树则无需继续计算
  173.     if(BiTreeEmpty(T)) {
  174.         return '\0';
  175.     }
  177.     // 获取结点e的指针
  178.     p = EPtr(T, e);
  180.     // 如果找到了元素e
  181.     if(p != NULL && p->lchild != NULL) {
  182.         return p->lchild->data;
  183.     }
  185.     return '\0';
  186. }
  188. /*
  189.  * 右孩子
  190.  *
  191.  * 返回二叉树中结点e的右孩子结点。
  192.  */
  193. TElemType RightChild(BiTree T, TElemType e) {
  194.     BiTree p;
  196.     // 遇到空树则无需继续计算
  197.     if(BiTreeEmpty(T)) {
  198.         return '\0';
  199.     }
  201.     // 获取结点e的指针
  202.     p = EPtr(T, e);
  204.     // 如果找到了元素e
  205.     if(p != NULL && p->rchild != NULL) {
  206.         return p->rchild->data;
  207.     }
  209.     return '\0';
  210. }
  212. /*
  213.  * 左兄弟
  214.  *
  215.  * 返回二叉树中结点e的左兄弟结点。
  216.  */
  217. TElemType LeftSibling(BiTree T, TElemType e) {
  218.     BiTree p;
  220.     // 遇到空树则无需继续计算
  221.     if(BiTreeEmpty(T)) {
  222.         return '\0';
  223.     }
  225.     // 获取结点e的双亲结点的指针
  226.     p = PPtr(T, e);
  228.     // 如果找到了元素e的双亲
  229.     if(p != NULL && p->lchild != NULL) {
  230.         return p->lchild->data;
  231.     }
  233.     return '\0';
  234. }
  236. /*
  237.  * 右兄弟
  238.  *
  239.  * 返回二叉树中结点e的右兄弟结点。
  240.  */
  241. TElemType RightSibling(BiTree T, TElemType e) {
  242.     BiTree p;
  244.     // 遇到空树则无需继续计算
  245.     if(BiTreeEmpty(T)) {
  246.         return '\0';
  247.     }
  249.     // 获取结点e的双亲结点的指针
  250.     p = PPtr(T, e);
  252.     // 如果找到了元素e的双亲
  253.     if(p != NULL && p->rchild != NULL) {
  254.         return p->rchild->data;
  255.     }
  257.     return '\0';
  258. }
  260. /*
  261.  * 插入
  262.  *
  263.  * 已知c为与T不相交的非空二叉树，且c的右子树为空，
  264.  * 根据LR的取值(0或1)，将c插入为T中结点p的左子树/右子树，
  265.  * 并且，将p结点原有的左子树/右子树嫁接为二叉树c的右子树。
  266.  */
  267. Status InsertChild(BiTree T, TElemType p, int LR, BiTree c) {
  268.     BiTree p_ptr;
  270.     // 如果待插入的树为空树则无需继续计算
  271.     if(BiTreeEmpty(c)) {
  272.         return ERROR;
  273.     }
  275.     // 获取结点p的指针
  276.     p_ptr = EPtr(T, p);
  278.     // 如果p结点不存在，则返回错误提示
  279.     if(p_ptr == NULL) {
  280.         return ERROR;
  281.     }
  283.     // 将c插入为p的左子树
  284.     if(LR==0) {
  285.         // 如果p处存在左子树，则摘下p的左子树，插入为c的右子树
  286.         if(p_ptr->lchild!=NULL) {
  287.             c->rchild = p_ptr->lchild;
  288.         }
  290.         p_ptr->lchild = c;
  291.     } else {
  292.         // 如果p处存在右子树，则摘下p的右子树，插入为c的右子树
  293.         if(p_ptr->rchild!=NULL) {
  294.             c->rchild = p_ptr->rchild;
  295.         }
  297.         p_ptr->rchild = c;
  298.     }
  300.     return OK;
  301. }
  303. /*
  304.  * 删除
  305.  *
  306.  * 根据LR的取值(0或1)，删除结点p的左子树/右子树。
  307.  */
  308. Status DeleteChild(BiTree T, TElemType p, int LR) {
  309.     BiTree p_ptr;
  311.     // 遇到空树则无需继续计算
  312.     if(BiTreeEmpty(T)) {
  313.         return ERROR;
  314.     }
  316.     // 获取结点p的指针
  317.     p_ptr = EPtr(T, p);
  319.     // 如果p结点不存在，则返回错误提示
  320.     if(p_ptr == NULL) {
  321.         return ERROR;
  322.     }
  324.     // 如果需要删除p的左子树
  325.     if(LR == 0) {
  326.         ClearBiTree(&(p_ptr->lchild));
  328.         // 如果需要删除p的右子树
  329.     } else {
  330.         ClearBiTree(&(p_ptr->rchild));
  331.     }
  333.     return OK;
  334. }
  336. /*
  337.  * ████████ 算法6.1 ████████
  338.  *
  339.  * 先序遍历
  340.  */
  341. Status PreOrderTraverse(BiTree T, Status(Visit)(TElemType)) {
  342.     Status status;
  344.     status = PreTraverse(T, Visit);
  345.     printf("\n");
  347.     return status;
  348. }
  350. /*
  351.  * 中序遍历
  352.  */
  353. Status InOrderTraverse(BiTree T, Status(Visit)(TElemType)) {
  354.     Status status;
  356.     status = InTraverse(T, Visit);
  357.     printf("\n");
  359.     return status;
  360. }
  362. /*
  363.  * ████████ 算法6.2 ████████
  364.  *
  365.  * 中序遍历
  366.  *
  367.  *【注】
  368.  * 非递归算法
  369.  */
  370. Status InOrderTraverse_2(BiTree T, Status(Visit)(TElemType)) {
  371.     SqStack S;
  372.     BiTree p;
  374.     InitStack(&S);
  375.     Push(&S, T);    // 根指针入栈
  377.     while(!StackEmpty(S)) {
  378.         // 向左走到尽头
  379.         while(GetTop(S, &p) && p != NULL) {
  380.             Push(&S, p->lchild);
  381.         }
  383.         Pop(&S, &p);    // 空指针退栈
  385.         if(!StackEmpty(S)) {
  386.             // 访问结点
  387.             Pop(&S, &p);
  388.             if(!Visit(p->data)) {
  389.                 return ERROR;
  390.             }
  392.             // 向右一步
  393.             Push(&S, p->rchild);
  394.         }
  395.     }
  397.     printf("\n");
  399.     return OK;
  400. }
  402. /*
  403.  * ████████ 算法6.3 ████████
  404.  *
  405.  * 中序遍历
  406.  *
  407.  *【注】
  408.  * 非递归算法
  409.  */
  410. Status InOrderTraverse_3(BiTree T, Status(Visit)(TElemType)) {
  411.     SqStack S;
  412.     BiTree p;
  414.     InitStack(&S);
  416.     p = T;
  418.     while(p != NULL || !StackEmpty(S)) {
  419.         if(p != NULL) {
  420.             Push(&S, p);    // 根指针进栈
  421.             p = p->lchild;  // 遍历左子树
  422.         } else {
  423.             // 访问结点
  424.             Pop(&S, &p);
  425.             if(!Visit(p->data)) {
  426.                 return ERROR;
  427.             }
  429.             p = p->rchild;
  430.         }
  431.     }
  433.     printf("\n");
  435.     return OK;
  436. }
  438. /*
  439.  * 后序遍历
  440.  */
  441. Status PostOrderTraverse(BiTree T, Status(Visit)(TElemType)) {
  442.     Status status;
  444.     status = PostTraverse(T, Visit);
  445.     printf("\n");
  447.     return status;
  448. }
  450. /*
  451.  * 层序遍历
  452.  */
  453. Status LevelOrderTraverse(BiTree T, Status(Visit)(TElemType)) {
  454.     LinkQueue Q;
  455.     BiTree e;
  457.     // 二叉树为空
  458.     if(T == NULL) {
  459.         printf("\n");
  460.         return OK;
  461.     }
  463.     // 借助队列实现层序遍历
  464.     InitQueue(&Q);
  466.     // 根指针入队
  467.     EnQueue(&Q, T);
  469.     // 一直循环，直到队列为空
  470.     while(!QueueEmpty(Q)) {
  471.         DeQueue(&Q, &e);
  473.         // 访问元素
  474.         if(!Visit(e->data)) {
  475.             return ERROR;
  476.         }
  478.         // 左孩子入队
  479.         if(e->lchild != NULL) {
  480.             EnQueue(&Q, e->lchild);
  481.         }
  483.         // 右孩子入队
  484.         if(e->rchild != NULL) {
  485.             EnQueue(&Q, e->rchild);
  486.         }
  487.     }
  489.     printf("\n");
  491.     return OK;
  492. }
  495. /*━━━━━━━━━━━━━━━━━━━━━━ 仅限内部使用的函数 ━━━━━━━━━━━━━━━━━━━━━━*/
  497. // 创建二叉树的内部函数
  498. static void CreateTree(BiTree* T, FILE* fp) {
  499.     char ch;
  501.     // 读取当前结点的值
  502.     if(fp == NULL) {
  503.         scanf("%c", &ch);
  504.     } else {
  505.         ReadData(fp, "%c", &ch);
  506.     }
  508.     if(ch == '^') {
  509.         *T = NULL;
  510.     } else {
  511.         // 生成根结点
  512.         *T = (BiTree) malloc(sizeof(BiTNode));
  513.         if(!(*T)) {
  514.             exit(OVERFLOW);
  515.         }
  516.         (*T)->data = ch;
  517.         CreateTree(&((*T)->lchild), fp); // 创建左子树
  518.         CreateTree(&((*T)->rchild), fp); // 创建右子树
  519.     }
  520. }
  522. // 返回指向二叉树结点e的指针
  523. static BiTree EPtr(BiTree T, TElemType e) {
  524.     BiTree pl, pr;
  526.     if(T == NULL) {
  527.         return NULL;
  528.     }
  530.     // 如果找到了目标结点，直接返回其指针
  531.     if(T->data == e) {
  532.         return T;
  533.     }
  535.     // 在左子树中查找e
  536.     pl = EPtr(T->lchild, e);
  537.     if(pl != NULL) {
  538.         return pl;
  539.     }
  541.     // 在右子树中查找e
  542.     pr = EPtr(T->rchild, e);
  543.     if(pr != NULL) {
  544.         return pr;
  545.     }
  547.     return NULL;
  548. }
  550. // 返回指向二叉树结点e的双亲结点的指针
  551. static BiTree PPtr(BiTree T, TElemType e) {
  552.     BiTree pl, pr;
  554.     if(T == NULL || T->data == e) {
  555.         return NULL;
  556.     }
  558.     // e是T的左孩子
  559.     if(T->lchild != NULL && T->lchild->data == e) {
  560.         return T;
  561.     }
  563.     // e是T的右孩子
  564.     if(T->rchild != NULL && T->rchild->data == e) {
  565.         return T;
  566.     }
  568.     // 在左子树中查找e
  569.     pl = PPtr(T->lchild, e);
  570.     if(pl != NULL) {
  571.         return pl;
  572.     }
  574.     // 在右子树中查找e
  575.     pr = PPtr(T->rchild, e);
  576.     if(pr != NULL) {
  577.         return pr;
  578.     }
  580.     return NULL;
  581. }
  583. // 先序遍历的内部实现
  584. static Status PreTraverse(BiTree T, Status(Visit)(TElemType)) {
  585.     if(T) {
  586.         if(Visit(T->data)) {
  587.             if(PreTraverse(T->lchild, Visit)) {
  588.                 if(PreTraverse(T->rchild, Visit)) {
  589.                     return OK;
  590.                 }
  591.             }
  592.         }
  594.         return ERROR;
  596.         // 遇到空树则无需继续计算
  597.     } else {
  598.         return OK;
  599.     }
  600. }
  602. // 中序遍历的内部实现
  603. static Status InTraverse(BiTree T, Status(Visit)(TElemType)) {
  604.     if(T) {
  605.         if(InTraverse(T->lchild, Visit)) {
  606.             if(Visit(T->data)) {
  607.                 if(InTraverse(T->rchild, Visit)) {
  608.                     return OK;
  609.                 }
  610.             }
  611.         }
  613.         return ERROR;
  615.         // 遇到空树则无需继续计算
  616.     } else {
  617.         return OK;
  618.     }
  619. }
  621. // 后序遍历的内部实现
  622. static Status PostTraverse(BiTree T, Status(Visit)(TElemType)) {
  623.     if(T) {
  624.         if(PostTraverse(T->lchild, Visit)) {
  625.             if(PostTraverse(T->rchild, Visit)) {
  626.                 if(Visit(T->data)) {
  627.                     return OK;
  628.                 }
  629.             }
  630.         }
  632.         return ERROR;
  634.         // 遇到空树则无需继续计算
  635.     } else {
  636.         return OK;
  637.     }
  638. }
  641. /*━━━━━━━━━━━━━━━━━━━━━━ 图形化输出 ━━━━━━━━━━━━━━━━━━━━━━*/
  643. // 以图形化形式输出当前结构，仅限内部测试使用
  644. void PrintTree(BiTree T) {
  645.     int level, width;
  646.     int i, j, k, w;
  647.     int begin;
  648.     int distance;
  649.     TElemType** tmp;
  650.     LinkQueue Q;
  651.     BiTree e;
  653.     // 遇到空树则无需继续计算
  654.     if(BiTreeEmpty(T)) {
  655.         printf("\n");
  656.         return;
  657.     }
  659.     level = BiTreeDepth(T);         // （完全）二叉树结构高度
  660.     width = (int)pow(2, level)-1;   // （完全）二叉树结构宽度
  662.     // 动态创建行
  663.     tmp = (TElemType**)malloc(level* sizeof(TElemType*));
  665.     // 动态创建列
  666.     for(i = 0; i < level; i++) {
  667.         tmp[i] = (TElemType*)malloc(width* sizeof(TElemType));
  669.         // 初始化内存值为空字符
  670.         memset(tmp[i], '\0', width);
  671.     }
  673.     // 借助队列实现层序遍历
  674.     InitQueue(&Q);
  675.     EnQueue(&Q, T);
  677.     // 遍历树中所有元素，将其安排到二维数组tmp中合适的位置
  678.     for(i = 0; i < level; i++) {
  679.         w        = (int) pow(2, i);             // 二叉树当前层的宽度
  680.         distance = width / w;                   // 二叉树当前层的元素间隔
  681.         begin    = width / (int) pow(2, i + 1); // 二叉树当前层首个元素之前的空格数
  683.         for(k = 0; k < w; k++) {
  684.             DeQueue(&Q, &e);
  686.             if(e == NULL) {
  687.                 EnQueue(&Q, NULL);
  688.                 EnQueue(&Q, NULL);
  689.             } else {
  690.                 j = begin + k * (1 + distance);
  691.                 tmp[i][j] = e->data;
  693.                 // 左孩子入队
  694.                 EnQueue(&Q, e->lchild);
  696.                 // 右孩子入队
  697.                 EnQueue(&Q, e->rchild);
  698.             }
  699.         }
  700.     }
  702.     for(i = 0; i < level; i++) {
  703.         for(j = 0; j < width; j++) {
  704.             if(tmp[i][j] != '\0') {
  705.                 printf("%c", tmp[i][j]);
  706.             } else {
  707.                 printf(" ");
  708.             }
  709.         }
  710.         printf("\n");
  711.     }
  712. }

线索二叉树 __*

/* 线索二叉树结点定义 */
typedef struct BiThrNode {
    TElemType data;             // 结点元素
    struct BiThrNode* lchild;   // 左孩子指针
    struct BiThrNode* rchild;   // 右孩子指针
    PointerTag LTag;            // 左指针标记
    PointerTag RTag;            // 右指针标记

    struct BiThrNode* parent;   // 双亲结点指针，仅在非递归后序遍历后序后继线索二叉树时使用
} BiThrNode;

/*
 * 创建
 *
 * 按照预设的定义来创建二叉树。
 * 这里约定使用【先序序列】来创建二叉树。
 *
 *
 *【备注】
 *
 * 教材中默认从控制台读取数据。
 * 这里为了方便测试，避免每次运行都手动输入数据，
 * 因而允许选择从预设的文件path中读取测试数据。
 *
 * 如果需要从控制台读取数据，则path为NULL或者为空串，
 * 如果需要从文件中读取数据，则需要在path中填写文件名信息。
 */
Status CreateBiTree(BiThrTree* T, char* path) {
    FILE* fp;
    int readFromConsole;    // 是否从控制台读取数据

    // 如果没有文件路径信息，则从控制台读取输入
    readFromConsole = path == NULL || strcmp(path, "") == 0;

    if(readFromConsole) {
        printf("请输入二叉树的先序序列，如果没有子结点，使用^代替：");
        CreateTree(T, NULL);
    } else {
        // 打开文件，准备读取测试数据
        fp = fopen(path, "r");
        if(fp == NULL) {
            return ERROR;
        }
        CreateTree(T, fp);
        fclose(fp);
    }

    return OK;
}

/*
 * ████████ 算法6.6 ████████
 *
 * 中序遍历二叉树T，并将其全线索化为线索二叉树Thrt。
 * 注：这里的线索包括前驱线索与后继线索。
 */
Status InOrderThreading(BiThrTree* Thrt, BiThrTree T) {
    // 建立头结点
    *Thrt = (BiThrTree) malloc(sizeof(BiThrNode));
    if(!*Thrt) {
        exit(OVERFLOW);
    }

    (*Thrt)->data = '\0';

    (*Thrt)->LTag = Link;       // 左孩子，需要指向二叉树的根结点
    (*Thrt)->RTag = Thread;     // 右指针，需要指向中序序列最后一个元素，以便逆中序遍历线索二叉树

    (*Thrt)->rchild = *Thrt;

    // 若二叉树为空，则左指针回指
    if(!T) {
        (*Thrt)->lchild = *Thrt;
    } else {
        (*Thrt)->lchild = T;    // 指向二叉树头结点
        pre = *Thrt;            // 记录前驱信息，初始化为线索二叉树头结点

        InTheading(T);          // 中序遍历，以进行中序线索化

        pre->rchild = *Thrt;    // 最后一个结点指回线索二叉树头结点
        pre->RTag = Thread;     // 最后一个结点线索化
        (*Thrt)->rchild = pre;  // 头结点指向最后一个结点，建立双向联系
    }

    return OK;

}

/*
 * ████████ 算法6.5 ████████
 *
 * 中序遍历中序全线索二叉树（非递归算法）。
 *
 * 注：该方法可以验证后继线索是否正确
 */
Status InOrderTraverse_Thr(BiThrTree T, Status(Visit)(TElemType)) {
    BiThrTree p = T->lchild;    // p指向二叉树根结点（不同于线索二叉树的头结点）

    // 空树或遍历结束时，p==T
    while(p != T) {
        // 如果存在左孩子，则持续向左访问
        while(p->LTag == Link) {
            p = p->lchild;
        }

        // 访问左子树为空的结点（最左边）
        if(!Visit(p->data)) {
            return ERROR;
        }

        // 如果存在后继线索（即没有右子树）
        while(p->RTag == Thread && p->rchild != T) {
            p = p->rchild;   // 将p指向其后继
            Visit(p->data);  // 访问后继结点
        }

        // 访问右子树
        p = p->rchild;
    }

    printf("\n");

    return OK;
}


/*━━━━━━━━━━━━━━━━━━━━━━ 仅限内部使用的函数 ━━━━━━━━━━━━━━━━━━━━━━*/

// 创建二叉树的内部函数
static void CreateTree(BiThrTree* T, FILE* fp) {
    char ch;

    // 读取当前结点的值
    if(fp == NULL) {
        scanf("%c", &ch);
    } else {
        ReadData(fp, "%c", &ch);
    }

    if(ch == '^') {
        *T = NULL;
    } else {
        // 生成根结点
        *T = (BiThrTree) malloc(sizeof(BiThrNode));
        if(!(*T)) {
            exit(OVERFLOW);
        }
        (*T)->data = ch;
        CreateTree(&((*T)->lchild), fp); // 创建左子树
        CreateTree(&((*T)->rchild), fp); // 创建右子树
    }
}

/*
 * ████████ 算法6.7 ████████
 *
 * 中序全线索化的内部实现
 */
static void InTheading(BiThrTree p) {
    if(p == NULL) {
        return;
    }

    InTheading(p->lchild);  // 线索化左子树

    // 如果当前结点的左子树为空，则需要建立前驱线索
    if(!p->lchild) {
        p->LTag = Thread;
        p->lchild = pre;

        /*
         * 如果左子树不为空，添加左孩子标记。
         * 教材中缺少这一步骤，这会导致出现一些幽灵BUG。
         * 这里的Link枚举值是零，如果编译器在动态分配内存后恰好把该标记初始化为0，
         * 那么效果跟手动设置Link是一样的。但如果编译器没有初始化零值，那么就会出BUG。
         */
    } else {
        p->LTag = Link;
    }

    // 如果前驱结点的右子树为空，则为前驱结点建立后继线索
    if(!pre->rchild) {
        pre->RTag = Thread;
        pre->rchild = p;

        /*
         * 如果右子树不为空，添加右孩子标记。
         * 教材中缺少这一步骤，这会导致出现一些幽灵BUG，理由同上。
         */
    } else {
        pre->RTag = Link;
    }

    pre = p;                // pre向前挪一步

    InTheading(p->rchild);  // 线索化右子树
}


/*━━━━━━━━━━━━━━━━━━━━━━ 辅助函数 ━━━━━━━━━━━━━━━━━━━━━━*/

/*
 * 逆中序遍历中序全线索二叉树（非递归算法）。
 *
 * 注：该方法可以验证前驱线索是否正确
 */
Status InOrderTraverse_Thr_Inverse(BiThrTree T, Status(Visit)(TElemType)) {
    BiThrTree p = T->rchild;    // p指向二叉树中序遍历的最后一个结点，这也相当于是T的左子树上中序遍历的最后一个结点

    // 空树或遍历结束时，p==T
    while(p != T) {
        // 访问结点p，该结点是某棵左子树上中序遍历的最后一个结点
        if(!Visit(p->data)) {
            return ERROR;
        }

        // 如果存在前驱线索（即没有左子树）
        while(p->LTag == Thread && p->lchild != T) {
            p = p->lchild;   // 将p指向其前驱
            Visit(p->data);  // 访问前驱结点
        }

        // 向左前进一步，可能遇到左子树，也可能遇到终点T
        p = p->lchild;

        // 如果没有遇到终点，即存在左子树，则找到该左子树上中序遍历的最后一个结点
        if(p != T) {
            while(p->RTag == Link) {
                p = p->rchild;
            }
        }
    }

    printf("\n");

    return OK;
}
  • 二叉树和森林的转换__ * ```c / (双亲)树的结点定义 / typedef struct PTNode { TElemType data; int parent; // 双亲位置域 } PTNode;

/*

  • (双亲)树类型定义 【注】
  • 1.树中结点在nodes中”紧邻”存储，没有空隙
  • 2.树根r可能出现在nodes的任意位置
  • 3.除根结点外，其他结点依次按层序顺着根结点往下排列（这一点与教材图示可能会有区别）
  • 4.nodes数组是循环使用的（这一点教材未提到）
  • 5.这里假设nodes空间是足够大的，可以视需求将其改为动态分配存储 */ typedef struct { PTNode nodes[MAX_TREE_SIZE]; // 存储树中结点 int r; // 树根位置(索引) int n; // 树的结点数 } PTree;

/ 树中某个结点的信息 / typedef struct{ int row; // 当前结点所处的行 int col; // 当前结点所处的列 int childIndex; // 当前结点是第几个孩子 int firstChild; // 当前结点的第一个孩子在树中的索引 int lastChild; // 当前结点的最后一个孩子在树中的索引 } Pos;

```c
/* 孩子结点定义 */
typedef struct CTNode {
    int child;              // 该孩子在树中的索引
    struct CTNode* next;    // 指向下一个孩子
} CTNode;

/* 指向孩子结点的指针 */
typedef CTNode* ChildPtr;

/* (双亲)树的结点定义 */
typedef struct {
    int parent;             // 双亲位置域
    TElemType data;         // 当前结点
    ChildPtr firstchild;    // 孩子链表头指针
} CTBox;

/*
 * (双亲)树类型定义
 *
 *【注】
 * 1.树中结点在nodes中"紧邻"存储，没有空隙
 * 2.树根r可能出现在nodes的任意位置
 * 3.除根结点外，其他结点依次按层序顺着根结点往下排列（这一点与教材图示可能会有区别）
 * 4.nodes数组是循环使用的（这一点教材未提到）
 * 5.这里假设nodes空间是足够大的，可以视需求将其改为动态分配存储
 */
typedef struct {
    CTBox nodes[MAX_TREE_SIZE]; // 存储树中结点
    int r;  // 树根位置(索引)
    int n;  // 树的结点数
} CTree;

/* (孩子-兄弟)树的结点定义 */
typedef struct CSNode {
    TElemType data;
    struct CSNode* firstchild;  // 指向长子
    struct CSNode* nextsibling; // 指向右兄弟
} CSNode;

/* (孩子-兄弟)树类型定义 */
typedef CSNode* CSTree;
  • 二叉树的基本操作（遍历、查找等）__* ```c /*
    • 二叉树类型定义，0号单元存储根结点。 【注】
    • 在二叉树的顺序结构中，其元素是按照完全顺序二叉树的层序序列排列的。 */ typedef TElemType SqBiTree[MAX_TREE_SIZE];

// 先序遍历的内部实现 static Status PreTraverse(SqBiTree T, Status(Visit)(TElemType), int i) { // 越界 if(i >= MAX_TREE_SIZE) { return ERROR; }

if(T[i]) {
    if(Visit(T[i])) {
        if(PreTraverse(T, Visit, 2 * i + 1)) {
            if(PreTraverse(T, Visit, 2 * i + 2)) {
                return OK;
            }
        }
    }

    return ERROR;

    // 遇到空树则无需继续计算
} else {
    return OK;
}

}

// 中序遍历的内部实现 static Status InTraverse(SqBiTree T, Status(Visit)(TElemType), int i) { // 越界 if(i >= MAX_TREE_SIZE) { return ERROR; }

if(T[i]) {
    if(InTraverse(T, Visit, 2 * i + 1)) {
        if(Visit(T[i])) {
            if(InTraverse(T, Visit, 2 * i + 2)) {
                return OK;
            }
        }

    }

    return ERROR;

    // 遇到空树则无需继续计算
} else {
    return OK;
}

}

// 后序遍历的内部实现 static Status PostTraverse(SqBiTree T, Status(Visit)(TElemType), int i) { // 越界 if(i >= MAX_TREE_SIZE) { return ERROR; }

if(T[i]) {
    if(PostTraverse(T, Visit, 2 * i + 1)) {
        if(PostTraverse(T, Visit, 2 * i + 2)) {
            if(Visit(T[i])) {
                return OK;
            }

        }
    }

    return ERROR;

    // 遇到空树则无需继续计算
} else {
    return OK;
}

}

/*

  • 取值 *

  • 返回二叉树中指定结点的值。 */ TElemType Value(SqBiTree T, TElemType e) { int index;

    // 遇到空树则无需继续计算 if(BiTreeEmpty(T)) {

     return '\0';

    }

    // 获取结点e的索引 index = EIndex(T, e, 0);

    // 如果没有找到元素e if(index == -1) {

     return '\0';

    } else {

     return T[index];

    } }

// 返回二叉树结点e的索引号，i是结点p的索引号 static int EIndex(SqBiTree T, TElemType e, int i) { int cl, cr;

// 已经越界
if(i >= MAX_TREE_SIZE) {
    return -1;
}

// e的值不合规
if(e == '\0') {
    return -1;
}

// 找到了元素e
if(T[i] == e) {
    return i;
}

// 在左子树中查找
cl = EIndex(T, e, 2 * i + 1);
if(cl != -1) {
    return cl;
}

// 在右子树中查找
cr = EIndex(T, e, 2 * i + 2);
if(cr != -1) {
    return cr;
}

return -1;

}

```c
/* 二叉树结点定义 */
typedef struct BiTNode {
    TElemType data;             // 结点元素
    struct BiTNode* lchild;     // 左孩子指针
    struct BiTNode* rchild;     // 右孩子指针
} BiTNode;

/* 指向二叉树结点的指针 */
typedef BiTNode* BiTree;

// 先序遍历的内部实现
static Status PreTraverse(BiTree T, Status(Visit)(TElemType)) {
    if(T) {
        if(Visit(T->data)) {
            if(PreTraverse(T->lchild, Visit)) {
                if(PreTraverse(T->rchild, Visit)) {
                    return OK;
                }
            }
        }

        return ERROR;

        // 遇到空树则无需继续计算
    } else {
        return OK;
    }
}

// 中序遍历的内部实现
static Status InTraverse(BiTree T, Status(Visit)(TElemType)) {
    if(T) {
        if(InTraverse(T->lchild, Visit)) {
            if(Visit(T->data)) {
                if(InTraverse(T->rchild, Visit)) {
                    return OK;
                }
            }
        }

        return ERROR;

        // 遇到空树则无需继续计算
    } else {
        return OK;
    }
}

// 后序遍历的内部实现
static Status PostTraverse(BiTree T, Status(Visit)(TElemType)) {
    if(T) {
        if(PostTraverse(T->lchild, Visit)) {
            if(PostTraverse(T->rchild, Visit)) {
                if(Visit(T->data)) {
                    return OK;
                }
            }
        }

        return ERROR;

        // 遇到空树则无需继续计算
    } else {
        return OK;
    }
}

// 返回指向二叉树结点e的指针
static BiTree EPtr(BiTree T, TElemType e) {
    BiTree pl, pr;

    if(T == NULL) {
        return NULL;
    }

    // 如果找到了目标结点，直接返回其指针
    if(T->data == e) {
        return T;
    }

    // 在左子树中查找e
    pl = EPtr(T->lchild, e);
    if(pl != NULL) {
        return pl;
    }

    // 在右子树中查找e
    pr = EPtr(T->rchild, e);
    if(pr != NULL) {
        return pr;
    }

    return NULL;
}

Huffman树构造（带权路径长度）

/* 赫夫曼树结点定义，是一种双亲存储结构 */
typedef struct {
    unsigned int weight;    // 权值
    unsigned int parent;    // 双亲位置
    unsigned int lchild;    // 左孩子位置
    unsigned int rchild;    // 右孩子位置
} HTNode;

/*
 * 赫夫曼树类型定义
 *
 *【注】
 * 1.0号单元的weight域指示赫夫曼树的结点数量
 * 2.其存储空间会动态分配
 */
typedef HTNode* HuffmanTree;

/*
 * 赫夫曼编码表的类型定义，包含了多个字符的赫夫曼编码
 *
 *【注】
 * 1.0号单元是弃用的
 * 2.存储空间需要动态分配
 */
typedef char** HuffmanCode;

/*
 * 初始化环境
 *
 * 主要用来初始化权值信息。
 *
 *
 *【备注】
 *
 * 教材中默认从控制台读取数据。
 * 这里为了方便测试，避免每次运行都手动输入数据，
 * 因而允许选择从预设的文件path中读取测试数据。
 *
 * 如果需要从控制台读取数据，则path为NULL或者为空串，
 * 如果需要从文件中读取数据，则需要在path中填写文件名信息。
 */
Status InitEnvironment(int** w, int* n, char* path) {
    FILE* fp;
    int readFromConsole;    // 是否从控制台读取数据

    // 如果没有文件路径信息，则从控制台读取输入
    readFromConsole = path == NULL || strcmp(path, "") == 0;

    if(readFromConsole) {
        printf("请输入赫夫曼树结点信息...\n");
        Init(w, n, NULL);
    } else {
        // 打开文件，准备读取测试数据
        fp = fopen(path, "r");
        if(fp == NULL) {
            return ERROR;
        }
        Init(w, n, fp);
        fclose(fp);
    }

    return OK;
}

/*
 * ████████ 算法6.12 ████████
 *
 * 编码
 * 1.根据指定的n个权值信息w来创建赫夫曼树HT。
 * 2.由赫夫曼树HT逆序计算赫夫曼编码值HC。
 *
 *【注】
 * 该算法与【算法6.13】作用一致。
 */
Status HuffmanCodeing_1(HuffmanTree* HT, HuffmanCode* HC, int* w, int n) {
    int m, i;
    HuffmanTree p;
    int s1, s2;
    char* cd;
    int start, c;
    unsigned int f;

    if(n <= 1) {
        return ERROR;
    }

    // 计算赫夫曼树结点数
    m = 2 * n - 1;

    *HT = (HuffmanTree) malloc((m + 1) * sizeof(HTNode));   // 0号单元未使用，但其weight域记录了原始的权值数量
    (*HT)[0].weight = n;

    // 记录权值信息（注意p应当指向索引1处，因为0号单元弃用了，而教材中错误地指向了0号单元）
    for(p = (*HT) + 1, i = 1; i <= n; ++i, ++p, ++w) {
        (*p).weight = *w;
        (*p).parent = 0;
        (*p).lchild = 0;
        (*p).rchild = 0;
    }

    // 后面的部分需要计算
    for(; i <= m; ++i, ++p) {
        (*p).weight = 0;
        (*p).parent = 0;
        (*p).lchild = 0;
        (*p).rchild = 0;
    }

    // 建赫夫曼树
    for(i = n + 1; i <= m; ++i) {
        // 在HT[1,i-1]中选择parent为0（未加入树），且weight最小的两个结点，其序号分别为s1和s2
        Select(*HT, i - 1, &s1, &s2);

        (*HT)[s1].parent = i;
        (*HT)[s2].parent = i;
        (*HT)[i].lchild = s1;
        (*HT)[i].rchild = s2;
        (*HT)[i].weight = (*HT)[s1].weight + (*HT)[s2].weight;
    }


    /* 从叶子到根逆向求每个字符的赫夫曼编码 */

    (*HC) = (HuffmanCode) malloc((n + 1) * sizeof(char*));  // 分配n个字符编码的头指针向量（0号单元弃用）
    cd = (char*) malloc(n * sizeof(char));  // 分配求编码的工作空间（每个编码长度最大为n-1）
    cd[n - 1] = '\0';   // 编码结束符

    // 逐个字符求赫夫曼编码
    for(i = 1; i <= n; ++i) {
        start = n - 1;    // 编码结束符位置

        // 从叶子到根逆向求编码
        for(c = i, f = (*HT)[i].parent; f != 0; c = f, f = (*HT)[f].parent) {
            if((*HT)[f].lchild == c) {
                cd[--start] = '0';
            } else {
                cd[--start] = '1';
            }
        }

        (*HC)[i] = (char*) malloc((n - start) * sizeof(char));  // 为第i个字符编码分配空间
        strcpy((*HC)[i], &cd[start]);   // 从cd复制编码（串）到HC
    }

    free(cd);   // 释放工作空间

    return OK;
}

/*
 * ████████ 算法6.13 ████████
 *
 * 编码
 * 1.根据指定的n个权值信息w来创建赫夫曼树HT。
 * 2.先序遍历赫夫曼树HT计算赫夫曼编码值HC。
 *
 *【注】
 * 该算法与【算法6.12】作用一致。
 */
Status HuffmanCodeing_2(HuffmanTree* HT, HuffmanCode* HC, int* w, int n) {
    int m, i;
    HuffmanTree p;
    int s1, s2;
    unsigned int r;
    int cdlen;
    char* cd;
    HuffmanTree H;  // HT的一个副本

    if(n <= 1) {
        return ERROR;
    }

    // 计算赫夫曼树结点数
    m = 2 * n - 1;

    *HT = (HuffmanTree) malloc((m + 1) * sizeof(HTNode));   // 0号单元未使用，但其weight域记录了原始的权值数量
    (*HT)[0].weight = n;

    // 记录权值信息（注意p应当指向索引1处，因为0号单元弃用了，而教材中错误地指向了0号单元）
    for(p = (*HT) + 1, i = 1; i <= n; ++i, ++p, ++w) {
        (*p).weight = *w;
        (*p).parent = 0;
        (*p).lchild = 0;
        (*p).rchild = 0;
    }

    // 后面的部分需要计算
    for(; i <= m; ++i, ++p) {
        (*p).weight = 0;
        (*p).parent = 0;
        (*p).lchild = 0;
        (*p).rchild = 0;
    }

    // 建赫夫曼树
    for(i = n + 1; i <= m; ++i) {
        // 在HT[1,i-1]中选择parent为0（未加入树），且weight最小的两个结点，其序号分别为s1和s2
        Select(*HT, i - 1, &s1, &s2);

        (*HT)[s1].parent = i;
        (*HT)[s2].parent = i;
        (*HT)[i].lchild = s1;
        (*HT)[i].rchild = s2;
        (*HT)[i].weight = (*HT)[s1].weight + (*HT)[s2].weight;
    }


    /* 无栈非递归遍历赫夫曼树，求赫夫曼编码 */

    (*HC) = (HuffmanCode) malloc((n + 1) * sizeof(char*));  // 分配n个字符编码的头指针向量（0号单元弃用）
    cd = (char*) malloc(n * sizeof(char));  // 分配求编码的工作空间（每个编码长度最大为n-1）

    r = m;
    cdlen = 0;

    // 后续再赫夫曼树的副本上进行操作
    H = (HuffmanTree) malloc((m + 1) * sizeof(HTNode));
    for(i = 0; i <= m; ++i) {
        H[i] = (*HT)[i];
        H[i].weight = 0;
    }

    while(r != 0) {
        // 第一次访问此结点，需要向左遍历
        if(H[r].weight == 0) {
            H[r].weight = 1;

            // 存在左孩子
            if(H[r].lchild != 0) {
                // 向左走一步
                r = H[r].lchild;
                cd[cdlen++] = '0';

                // 不存在左孩子，也不存在右孩子，即遇到了叶子结点
            } else if(H[r].rchild == 0) {
                (*HC)[r] = (char*) malloc((cdlen + 1) * sizeof(char));
                cd[cdlen] = '\0';
                strcpy((*HC)[r], cd);   // 复制编码串
            }

            // 第二次访问此结点，需要向右遍历
        } else if(H[r].weight == 1) {
            H[r].weight = 2;

            if(H[r].rchild != 0) {
                r = H[r].rchild;
                cd[cdlen++] = '1';
            }

            // 第三次访问，需要回退到父结点
        } else {
            r = H[r].parent;    // 退回到父结点
            cdlen--;                // 编码长度减1
        }
    }

    return OK;
}

/*
 * 解码
 * 根据给定的n个赫夫曼编码HC，计算其代表的权值。
 */
Status HuffmanDecoding(HuffmanTree HT, HuffmanCode HC, int** w, int n) {
    int i, j, k;
    int r;
    char* s;

    if(n <= 0) {
        return ERROR;
    }

    (*w) = (int*) malloc(n * sizeof(int));

    // 根结点位置
    r = 2 * n - 1;

    for(i = 1; i <= n; i++) {
        s = HC[i];

        k = r;

        // 从根结点往下找
        for(j = 0; j < strlen(s); j++) {
            if(s[j] == '0') {
                k = HT[k].lchild;   // 向左
            } else if(s[j] == '1') {
                k = HT[k].rchild;   // 向右
            } else {
                return ERROR;
            }
        }

        (*w)[i - 1] = HT[k].weight;
    }

    return OK;
}


/*━━━━━━━━━━━━━━━━━━━━━━ 仅限内部使用的函数 ━━━━━━━━━━━━━━━━━━━━━━*/

// 初始化环境的内部实现
static Status Init(int** w, int* n, FILE* fp) {
    int i;

    if(fp == NULL) {
        printf("请输入赫夫曼树叶子结点数量：");
        scanf("%d", n);

        if(*n <= 0) {
            *w = NULL;
            return ERROR;
        }

        *w = (int*) malloc((*n) * sizeof(int));

        printf("请输入 %d 个权值信息：", *n);
        for(i = 0; i < *n; i++) {
            scanf("%d", *w + i);
        }
    } else {
        // 录入元素数量
        ReadData(fp, "%d", n);

        if(*n <= 0) {
            *w = NULL;
            return ERROR;
        }

        *w = (int*) malloc((*n) * sizeof(int));

        // 录入结点权值信息
        for(i = 0; i < *n; i++) {
            ReadData(fp, "%d", *w + i);
        }
    }

    return OK;
}

// 在赫夫曼树结点[1...end]中依次选出权值最小且未编入树的两个结点的序号s1、s2。
static void Select(HuffmanTree HT, int end, int* s1, int* s2) {
    int i;
    int w1, w2;

    w1 = w2 = INT_MAX;

    for(i = 1; i <= end; i++) {
        // 忽略已经加入树的结点
        if(HT[i].parent != 0) {
            continue;
        }

        if(HT[i].weight < w1) {
            *s2 = *s1;
            w2 = w1;

            *s1 = i;
            w1 = HT[i].weight;
        } else if(HT[i].weight >= w1 && HT[i].weight < w2) {
            *s2 = i;
            w2 = HT[i].weight;
        } else {
            // HT[i].weight>=w2
        }
    }
}


/*━━━━━━━━━━━━━━━━━━━━━━ 图形化输出 ━━━━━━━━━━━━━━━━━━━━━━*/

// 打印赫夫曼树结构。
void PrintHuffmanTree(HuffmanTree HT) {
    int i;

    printf("+-------+--------+--------+--------+--------+\n");
    printf("| index | weight | parent | lchild | rchild |\n");
    printf("+-------+--------+--------+--------+--------+\n");
    printf("|  %3d  |  %4d  |        |        |        |\n", 0, HT[0].weight);
    printf("+-------+--------+--------+--------+--------+\n");
    for(i = 1; i <= 2 * HT[0].weight - 1; i++) {
        printf("|  %3d  |  %4d  |   %2d   |   %2d   |   %2d   |\n", i, HT[i].weight, HT[i].parent, HT[i].lchild, HT[i].rchild);
    }
    printf("+-------+--------+--------+--------+--------+\n");
}

// 打印赫夫曼编码。
void PrintHuffmanCode(HuffmanTree HT, HuffmanCode HC) {
    int i;

    printf("+-------+--------+-------------\n");
    printf("| index | weight | HuffmanCode \n");
    printf("+-------+--------+-------------\n");
    printf("|  %3d  |  %4d  | \n", 0, HT[0].weight);
    printf("+-------+--------+-------------\n");
    for(i = 1; i <= HT[0].weight; i++) {
        printf("|  %3d  |  %4d  -> %s\n", i, HT[i].weight, HC[i]);
    }
    printf("+-------+--------+-------------\n");
}

// 打印赫夫曼编码对应的权值信息。
void PrintWeight(HuffmanCode HC, int* w, int n) {
    int i;

    printf("+-------+-------------+--------+\n");
    printf("| index | HuffmanCode | weight |\n");
    printf("+-------+-------------+--------+\n");
    for(i = 1; i <= n; i++) {
        printf("|  %3d  | %11s |  %4d  |\n", i, HC[i], w[i - 1]);
    }
    printf("+-------+-------------+--------+\n");
}

第七章 图

图的定义（度、入度、初度）
图复习提要（20级） - 图42由顶点集复习提要（20级） - 图43和边集E组成，记为复习提要（20级） - 图44#card=math&code=G%3D%28V%EF%BC%8CE%29&id=VWSyu)

  1. 复习提要（20级） - 图45#card=math&code=V%28G%29&id=jD9rp)表示图复习提要（20级） - 图46中顶点的有限非空集。用复习提要（20级） - 图47表示图复习提要（20级） - 图48中顶点的个数，也称为图复习提要（20级） - 图49的阶
  2. 复习提要（20级） - 图50#card=math&code=E%28G%29&id=XJr05)表示图复习提要（20级） - 图51中顶点之间的关系（边）集合。用复习提要（20级） - 图52表示图复习提要（20级） - 图53中边的条数。

度：以该顶点为一个端点的边数目
无向图中顶点复习提要（20级） - 图54的度是指依附于该顶点的边的条数，记为复习提要（20级） - 图55

有向图中顶点复习提要（20级） - 图56的度分为出度和入度
入度（ID）是以顶点复习提要（20级） - 图57为终点的有向边的数目
出度（OD）是以顶点复习提要（20级） - 图58为起点的有向边的数目

  • 图的存储结构（邻接矩阵、邻接表）__*

邻接矩阵

// 图的类型
typedef enum {
    DG,     // 0-有向图
    DN,     // 1-有向网(带权值)
    UDG,    // 2-无向图
    UDN     // 3-无向网(带权值)
} GraphKind;

/*
 * 顶点关系类型
 *
 * 在无权图中，该值通常为0或1，表示两顶点是否直接连通；
 * 在有权图中，该值通常为权值。
 */
typedef int VRType;

// 边的相关附加信息
typedef struct {
    // 如果有的话，后续会添加相应的属性
} InfoType;

// 边的类型，每条边上可能有附加信息info
typedef struct ArcCell {
    VRType adj;  // 顶点关系，在有权图跟无权图中的含义不同
    InfoType* info; // 边的附加信息，通常忽略
} ArcCell;

/* 图/网的数组(邻接矩阵)存储表示类型定义 */
typedef struct {
    VertexType vexs[MAX_VERTEX_NUM];               // 顶点向量
    ArcCell arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];  // 邻接矩阵
    int vexnum, arcnum;                            // 图/网的顶点数和弧数
    GraphKind kind;                                // 图的类型标志
} MGraph;

/*
 * ████████ 算法7.1 ████████
 *
 * 创建图/表
 *
 *【备注】
 *
 * 教材中默认从控制台读取数据。
 * 这里为了方便测试，避免每次运行都手动输入数据，
 * 因而允许选择从预设的文件path中读取测试数据。
 *
 * 如果需要从控制台读取数据，则path为NULL，或path[kind]为""。
 * 如果需要从文件中读取数据，则需要在path中填写文件名信息。
 */
Status CreateGraph(MGraph* G, char* path[]) {
    int readFromConsole;    // 是否从控制台读取数据
    int kind;
    Status flag;

    printf("请输入图的类型(0-有向图 │ 1-有向网 │ 2-无向图 │ 3-无向网)：");
    scanf("%d", &kind);

    // 类型不合规
    if(kind < 0 || kind > 3) {
        return ERROR;
    }

    // 如果没有文件路径信息，则从控制台读取输入
    readFromConsole = (path == NULL) || strcmp(path[kind], "") == 0;

    // 需要从文件读取
    if(readFromConsole) {
        (*G).kind = kind;   // 记录图/网的类型
    } else {
        // 打开文件，准备读取测试数据
        fp = fopen(path[kind], "r");
        if(fp == NULL) {
            return ERROR;
        }

        // 录入图的类型
        ReadData(fp, "%d", &((*G).kind));
    }

    // 随机创建有向图/网或无向图/网的一种
    switch((*G).kind) {
        case DG:
            flag = CreateDG(G);
            break;
        case DN:
            flag = CreateDN(G);
            break;
        case UDG:
            flag = CreateUDG(G);
            break;
        case UDN:
            flag = CreateUDN(G);
            break;
        default:
            flag = ERROR;
            break;
    }

    if(fp != NULL) {
        fclose(fp);
        fp = NULL;
    }

    return flag;
}

/*
 * 构造有向图
 */
static Status CreateDG(MGraph* G) {
    int i, j, k;
    ArcCell arcs = {0, NULL};   // 有向图每条边的初始值
    VertexType v1, v2;

    if(fp == NULL) {
        printf("请输入有向图的顶点数：");
        scanf("%d", &((*G).vexnum));
        printf("请输入有向图的弧数：");
        scanf("%d", &((*G).arcnum));
        printf("该有向图的弧上是否包含其他附加信息(0-不包含│1-包含)：");
        scanf("%d", &IncInfo);

        // 录入顶点集
        printf("请录入 %d 个顶点，不同顶点之间用空格隔开：", (*G).vexnum);
        for(i = 0; i < (*G).vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(stdin);
            scanf("%c", &((*G).vexs[i]));
        }
    } else {
        ReadData(fp, "%d", &((*G).vexnum)); // 录入顶点数
        ReadData(fp, "%d", &((*G).arcnum)); // 录入弧数
        ReadData(fp, "%d", &IncInfo);       // 判断弧上是否包含附加信息

        // 录入顶点集
        for(i = 0; i < (*G).vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(fp);
            ReadData(fp, "%c", &((*G).vexs[i]));
        }
    }

    // 初始化有向图的邻接矩阵
    for(i = 0; i < (*G).vexnum; i++) {
        for(j = 0; j < (*G).vexnum; j++) {
            (*G).arcs[i][j] = arcs;
        }
    }

    // 仅在控制台录入信息时输出此提示
    if(fp == NULL && (*G).arcnum != 0) {
        printf("请为有向图依次录入 %d 条弧的信息，顶点之间用空格隔开：\n", (*G).arcnum);
    }

    // 录入弧的信息
    for(k = 0; k < (*G).arcnum; k++) {
        if(fp == NULL) {
            printf("第 %2d 条弧：", k + 1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v2);
        } else {
            // 跳过空白，寻找下一个可读符号
            skipBlank(fp);
            ReadData(fp, "%c%c", &v1, &v2);
        }

        i = LocateVex(*G, v1);  // 获取顶点v1在顶点集中的位置
        j = LocateVex(*G, v2);  // 获取顶点v2在顶点集中的位置

        // 将指定的顶点关系设置为1，指示这两个顶点是直接连接的(注：这里没有验证下标是否越界)
        (*G).arcs[i][j].adj = 1;

        // 如果需要录入弧的其他附加信息
        if(IncInfo) {
            // 最后录入附加信息
            Input(*G, &((*G).arcs[i][j].info));
        }
    }

    // 从文件中读取数据时，最后其实应当判断一下是否读到了足够的信息
    return OK;
}

/*
 * 构造有向网
 */
static Status CreateDN(MGraph* G) {
    int i, j, k;
    ArcCell arcs = {INFINITE, NULL};    // 有向网每条弧的初始值
    VertexType v1, v2;
    VRType w;

    if(fp == NULL) {
        printf("请输入有向网的顶点数：");
        scanf("%d", &((*G).vexnum));
        printf("请输入有向网的弧数：");
        scanf("%d", &((*G).arcnum));
        printf("该有向网的弧上是否包含其他附加信息(0-不包含│1-包含)：");
        scanf("%d", &IncInfo);

        // 录入顶点集
        printf("请录入 %d 个顶点，不同顶点之间用空格隔开：", (*G).vexnum);
        for(i = 0; i < (*G).vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(stdin);
            scanf("%c", &((*G).vexs[i]));
        }
    } else {
        ReadData(fp, "%d", &((*G).vexnum)); // 录入顶点数
        ReadData(fp, "%d", &((*G).arcnum)); // 录入弧数
        ReadData(fp, "%d", &IncInfo);       // 判断弧上是否包含附加信息

        // 录入顶点集
        for(i = 0; i < (*G).vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(fp);
            ReadData(fp, "%c", &((*G).vexs[i]));
        }
    }

    // 初始化有向网的邻接矩阵
    for(i = 0; i < (*G).vexnum; i++) {
        for(j = 0; j < (*G).vexnum; j++) {
            (*G).arcs[i][j] = arcs;
        }
    }

    // 仅在控制台录入信息时输出此提示
    if(fp == NULL && (*G).arcnum != 0) {
        printf("请为有向网依次录入 %d 条弧(带权值)的信息，顶点及权值之间用空格隔开：\n", (*G).arcnum);
    }

    // 录入弧的信息
    for(k = 0; k < (*G).arcnum; k++) {
        if(fp == NULL) {
            printf("第 %2d 条弧及其权值：", k + 1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v2);
            scanf("%d", &w);
        } else {
            // 跳过空白，寻找下一个可读符号
            skipBlank(fp);
            ReadData(fp, "%c%c%d", &v1, &v2, &w);
        }

        i = LocateVex(*G, v1);  // 获取顶点v1在顶点集中的位置
        j = LocateVex(*G, v2);  // 获取顶点v2在顶点集中的位置

        // 在指定的顶点关系上记录权值(注：这里没有验证下标是否越界)
        (*G).arcs[i][j].adj = w;

        // 如果需要录入弧的其他附加信息
        if(IncInfo) {
            // 最后录入附加信息
            Input(*G, &((*G).arcs[i][j].info));
        }
    }

    // 从文件中读取数据时，最后其实应当判断一下是否读到了足够的信息
    return OK;
}

/*
 * 构造无向图
 */
static Status CreateUDG(MGraph* G) {
    int i, j, k;
    ArcCell arcs = {0, NULL};   // 无向图每条边的初始值
    VertexType v1, v2;

    if(fp == NULL) {
        printf("请输入无向图的顶点数：");
        scanf("%d", &((*G).vexnum));
        printf("请输入无向图的边数：");
        scanf("%d", &((*G).arcnum));
        printf("该无向图的边上是否包含其他附加信息(0-不包含│1-包含)：");
        scanf("%d", &IncInfo);

        // 录入顶点集
        printf("请录入 %d 个顶点，不同顶点之间用空格隔开：", (*G).vexnum);
        for(i = 0; i < (*G).vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(stdin);
            scanf("%c", &((*G).vexs[i]));
        }
    } else {
        ReadData(fp, "%d", &((*G).vexnum)); // 录入顶点数
        ReadData(fp, "%d", &((*G).arcnum)); // 录入边数
        ReadData(fp, "%d", &IncInfo);       // 判断边上是否包含附加信息

        // 录入顶点集
        for(i = 0; i < (*G).vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(fp);
            ReadData(fp, "%c", &((*G).vexs[i]));
        }
    }

    // 初始化无向图的邻接矩阵
    for(i = 0; i < (*G).vexnum; i++) {
        for(j = 0; j < (*G).vexnum; j++) {
            (*G).arcs[i][j] = arcs;
        }
    }

    // 仅在控制台录入信息时输出此提示
    if(fp == NULL && (*G).arcnum != 0) {
        printf("请为无向图依次录入 %d 条边的信息，顶点之间用空格隔开：\n", (*G).arcnum);
    }

    // 录入边的信息
    for(k = 0; k < (*G).arcnum; k++) {
        if(fp == NULL) {
            printf("第 %2d 条边：", k + 1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v2);
        } else {
            // 跳过空白，寻找下一个可读符号
            skipBlank(fp);
            ReadData(fp, "%c%c", &v1, &v2);
        }

        i = LocateVex(*G, v1);  // 获取顶点v1在顶点集中的位置
        j = LocateVex(*G, v2);  // 获取顶点v2在顶点集中的位置

        // 将指定的顶点关系设置为1，指示这两个顶点是直接连接的(注：这里没有验证下标是否越界)
        (*G).arcs[i][j].adj = 1;

        // 如果需要录入边的其他附加信息
        if(IncInfo) {
            // 最后录入附加信息
            Input(*G, &((*G).arcs[i][j].info));
        }

        // 填充对称点
        (*G).arcs[j][i] = (*G).arcs[i][j];
    }

    // 从文件中读取数据时，最后其实应当判断一下是否读到了足够的信息
    return OK;
}

/*
 * ████████ 算法7.2 ████████
 *
 * 构造无向网
 */
static Status CreateUDN(MGraph* G) {
    int i, j, k;
    ArcCell arcs = {INFINITE, NULL};    // 无向网每条边的初始值
    VertexType v1, v2;
    VRType w;

    if(fp == NULL) {
        printf("请输入无向网的顶点数：");
        scanf("%d", &((*G).vexnum));
        printf("请输入无向网的边数：");
        scanf("%d", &((*G).arcnum));
        printf("该无向网的边上是否包含其他附加信息(0-不包含│1-包含)：");
        scanf("%d", &IncInfo);

        // 录入顶点集
        printf("请录入 %d 个顶点，不同顶点之间用空格隔开：", (*G).vexnum);
        for(i = 0; i < (*G).vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(stdin);
            scanf("%c", &((*G).vexs[i]));
        }
    } else {
        ReadData(fp, "%d", &((*G).vexnum)); // 录入顶点数
        ReadData(fp, "%d", &((*G).arcnum)); // 录入边数
        ReadData(fp, "%d", &IncInfo);       // 判断边上是否包含附加信息

        // 录入顶点集
        for(i = 0; i < (*G).vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(fp);
            ReadData(fp, "%c", &((*G).vexs[i]));
        }
    }

    // 初始化无向网的邻接矩阵
    for(i = 0; i < (*G).vexnum; i++) {
        for(j = 0; j < (*G).vexnum; j++) {
            (*G).arcs[i][j] = arcs;
        }
    }

    // 仅在控制台录入信息时输出此提示
    if(fp == NULL && (*G).arcnum != 0) {
        printf("请为无向网依次录入 %d 条边(带权值)的信息，顶点及权值之间用空格隔开：\n", (*G).arcnum);
    }

    // 录入边的信息
    for(k = 0; k < (*G).arcnum; k++) {
        if(fp == NULL) {
            printf("第 %2d 条边及其权值：", k + 1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v2);
            scanf("%d", &w);
        } else {
            // 跳过空白，寻找下一个可读符号
            skipBlank(fp);
            ReadData(fp, "%c%c%d", &v1, &v2, &w);
        }

        i = LocateVex(*G, v1);  // 获取顶点v1在顶点集中的位置
        j = LocateVex(*G, v2);  // 获取顶点v2在顶点集中的位置

        // 在指定的顶点关系上记录权值(注：这里没有验证下标是否越界)
        (*G).arcs[i][j].adj = w;

        // 如果需要录入边的其他附加信息
        if(IncInfo) {
            // 最后录入附加信息
            Input(*G, &((*G).arcs[i][j].info));
        }

        // 填充对称点
        (*G).arcs[j][i] = (*G).arcs[i][j];
    }

    // 从文件中读取数据时，最后其实应当判断一下是否读到了足够的信息
    return OK;
}

/*
 * 录入边/弧的相关附加信息
 */
static void Input(MGraph G, InfoType** info) {
    //录入边/弧的信息，本测试涉及到的边/弧默认无其他附加信息
}

/*
 * 销毁
 *
 * 邻接矩阵存储的图无需释放内存，只需重置相关遍历即可。
 */
Status DestroyGraph(MGraph* G) {
    (*G).vexnum = 0;
    (*G).arcnum = 0;
    IncInfo = 0;

    return OK;
}

/*
 * 查找
 *
 * 返回顶点u在图/网中的位置
 */
int LocateVex(MGraph G, VertexType u) {
    int i;

    for(i = 0; i < G.vexnum; i++) {
        if(G.vexs[i] == u) {
            return i;
        }
    }

    return -1;
}

/*
 * 取值
 *
 * 返回索引v处的顶点值
 */
VertexType GetVex(MGraph G, int v) {
    if(v < 0 || v >= G.vexnum) {
        return '\0';    // 指定的顶点不存在
    }

    return G.vexs[v];
}

/*
 * 赋值
 *
 * 将顶点v赋值为value
 */
Status PutVex(MGraph* G, VertexType v, VertexType value) {
    int k;

    // 首先需要判断该顶点是否存在
    k = LocateVex((*G), v);
    if(k == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    (*G).vexs[k] = value;

    return OK;
}

/*
 * 首个邻接点
 *
 * 返回顶点v的首个邻接点
 */
int FirstAdjVex(MGraph G, VertexType v) {
    int kv, j;
    VRType adj;

    kv = LocateVex(G, v);
    if(kv == -1) {
        return -1;    // 指定的顶点不存在
    }

    // 确定一个非连通标记
    if(G.kind == DG || G.kind == UDG) {
        adj = 0;            // 图
    } else if(G.kind == DN || G.kind == UDN) {
        adj = INFINITE;     // 网
    } else {
        return -1;
    }

    // 从头开始查找
    for(j = 0; j < G.vexnum; j++) {
        // 找到与v直接连接的顶点
        if(G.arcs[kv][j].adj != adj) {
            return j;
        }
    }

    return -1;
}

/*
 * 下一个邻接点
 *
 * 返回顶点v的(相对于w的)下一个邻接点
 */
int NextAdjVex(MGraph G, VertexType v, VertexType w) {
    int kv, kw, j;
    VRType adj;

    kv = LocateVex(G, v);
    if(kv == -1) {
        return -1;    // 指定的顶点不存在
    }

    kw = LocateVex(G, w);
    if(kw == -1) {
        return -1;    // 指定的顶点不存在
    }

    // 确定一个非连通标记
    if(G.kind == DG || G.kind == UDG) {
        adj = 0;        // 图
    } else if(G.kind == DN || G.kind == UDN) {
        adj = INFINITE; // 网
    } else {
        return -1;
    }

    // 从顶点w后开始查找
    for(j = kw + 1; j < G.vexnum; j++) {
        // 找到与v直接连接的顶点
        if(G.arcs[kv][j].adj != adj) {
            return j;
        }
    }

    return -1;
}

/*
 * 插入顶点
 *
 * 将指定的顶点v追加到顶点集中，未建立该顶点与其他顶点的关系
 */
Status InsertVex(MGraph* G, VertexType v) {
    int i, k;
    VRType adj;

    // 顶点数过多
    if((*G).vexnum == MAX_VERTEX_NUM) {
        return ERROR;
    }

    // 首先需要判断该顶点是否存在
    k = LocateVex(*G, v);
    if(k >= 0) {
        return ERROR;    // 指定的顶点存在时，无需重复添加
    }

    // 确定一个非连通标记
    if((*G).kind == DG || (*G).kind == UDG) {
        adj = 0;        // 图
    } else if((*G).kind == DN || (*G).kind == UDN) {
        adj = INFINITE; // 网
    } else {
        return ERROR;
    }

    (*G).vexs[(*G).vexnum] = v;
    (*G).vexnum++;

    for(i = 0; i < (*G).vexnum; i++) {
        (*G).arcs[i][(*G).vexnum - 1].adj = adj;
        (*G).arcs[(*G).vexnum - 1][i].adj = adj;
    }

    return OK;
}

/*
 * 删除顶点
 *
 * 从顶点集中删除指定的顶点v，注意需要更新相关的顶点关系
 */
Status DeleteVex(MGraph* G, VertexType v) {
    int i, j, k;
    VRType adj;

    k = LocateVex(*G, v);
    if(k == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    // 确定一个非连通标记
    if((*G).kind == DG || (*G).kind == UDG) {
        adj = 0;        // 图
    } else if((*G).kind == DN || (*G).kind == UDN) {
        adj = INFINITE; // 网
    } else {
        return ERROR;
    }

    // 更新边/弧的数量
    for(i = 0; i < (*G).vexnum; i++) {
        // 如果存在从顶点v出发的边，则边的数量减一
        if((*G).arcs[k][i].adj != adj) {
            (*G).arcnum--;
        }

        // 如果这是有向的图/网，依然需要更新边/弧的数量
        if((*G).kind == DG || (*G).kind == DN) {
            // 如果存在到达顶点v的边，则边的数量减一
            if((*G).arcs[i][k].adj != adj) {
                (*G).arcnum--;
            }
        }
    }

    // 将邻接矩阵中的顶点关系左移
    for(j = k + 1; j < (*G).vexnum; j++) {
        for(i = 0; i < (*G).vexnum; i++) {
            (*G).arcs[i][j - 1] = (*G).arcs[i][j];    // 右边的列挪到左边的列
        }
    }

    // 将邻接矩阵中的顶点关系上移
    for(i = k + 1; i < (*G).vexnum; i++) {
        // 注，由于上面进行左移的关系，所以这里的j是小于(*G).vexnum - 1
        for(j = 0; j < (*G).vexnum - 1; j++) {
            (*G).arcs[i - 1][j] = (*G).arcs[i][j];    // 下一行挪到上一行
        }
    }

    // 将该顶点从顶点集中移除
    for(i = k + 1; i < (*G).vexnum; i++) {
        (*G).vexs[i - 1] = (*G).vexs[i];
    }

    // 顶点数减一
    (*G).vexnum--;

    return OK;
}

/*
 * 插入边/弧<v, w>
 *
 * 如果当前图/网是无向的，则插入一条弧需要增加两个顶点关系，但弧的数量只增一。
 *
 * 对于图来说，可以在可变参数中列出边/弧的附加信息；
 * 对于网来说，可以在可变参数中依次列出边/弧的权值以及附加信息。
 */
Status InsertArc(MGraph* G, VertexType v, VertexType w, ...) {
    int kv, kw;
    VRType adj;                 // 顶点关系
    Boolean overlay = FALSE;    // 是否为覆盖添加
    InfoType* info = NULL;      // 边/弧的附加信息
    va_list ap;

    kv = LocateVex(*G, v);
    if(kv == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    kw = LocateVex(*G, w);
    if(kw == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    // 拒绝环
    if(kv == kw) {
        return ERROR;
    }

    /* 确定一个顶点关系 */

    // 对于图来说，连通关系用1表示
    if((*G).kind == DG || (*G).kind == UDG) {
        adj = 1;

        // 如果边/弧上存在附加信息
        if(IncInfo) {
            va_start(ap, w);                // 在w后查询首个可变参数
            info = va_arg(ap, InfoType*);   // 获取附加信息
            va_end(ap);
        }

        overlay = (*G).arcs[kv][kw].adj != 0;

        // 对于网来说，此处需要从可变参数中获取权值信息
    } else if((*G).kind == DN || (*G).kind == UDN) {
        va_start(ap, w);    // 在w后查询首个可变参数

        adj = va_arg(ap, VRType);   // 获取权值信息

        // 如果边/弧上存在附加信息
        if(IncInfo) {
            info = va_arg(ap, InfoType*);   // 获取附加信息
        }

        va_end(ap);

        overlay = (*G).arcs[kv][kw].adj != INFINITE;
    } else {
        return ERROR;
    }

    (*G).arcs[kv][kw].adj = adj;    // 记录顶点关系

    // 如果边/弧上存在附加信息，则记录附加关系
    if(IncInfo) {
        (*G).arcs[kv][kw].info = info;
    }

    // 如果是无向图/网，需要考虑对称性
    if((*G).kind == UDG || (*G).kind == UDN) {
        (*G).arcs[kw][kv] = (*G).arcs[kv][kw];
    }

    // 在非覆盖的情形下，才考虑更新边/弧的数量
    if(!overlay) {
        (*G).arcnum++;  // 不论有向无向，边/弧数只增一
    }

    return OK;
}

/*
 * 删除边/弧
 *
 * 此删除只是更新边/弧的连通关系
 */
Status DeleteArc(MGraph* G, VertexType v, VertexType w) {
    int kv, kw;
    VRType adj;
    Boolean found = FALSE;  // 是否存在待删除的边/弧

    kv = LocateVex(*G, v);
    if(kv == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    kw = LocateVex(*G, w);
    if(kw == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    // 确定一个非连通标记
    if((*G).kind == DG || (*G).kind == UDG) {
        adj = 0;        // 图

        found = (*G).arcs[kv][kw].adj != 0;
    } else if((*G).kind == DN || (*G).kind == UDN) {
        adj = INFINITE; // 网

        found = (*G).arcs[kv][kw].adj != INFINITE;
    } else {
        return ERROR;
    }

    // 标记这两个顶点已断开连接
    (*G).arcs[kv][kw].adj = adj;

    // 如果是无向图/网，需要考虑对称性
    if((*G).kind == UDG || (*G).kind == UDN) {
        (*G).arcs[kw][kv] = (*G).arcs[kv][kw];
    }

    // 在找到了指定的弧时，才考虑更新边/弧的数量
    if(found) {
        (*G).arcnum--;  // 不论有向无向，边/弧数只减一
    }

    return OK;
}

/*
 * ████████ 算法7.4 ████████
 *
 * 深度优先遍历(此处借助递归实现)
 */
void DFSTraverse(MGraph G, Status(Visit)(VertexType)) {
    int v;

    // 使用全局变量VisitFunc，使得DFS不必设置函数指针参数
    VisitFunc = Visit;

    // 访问标志数组初始化
    for(v = 0; v < G.vexnum; v++) {
        visited[v] = FALSE;
    }

    // 此处需要遍历的原因是并不能保证所有顶点都连接在了一起
    for(v = 0; v < G.vexnum; v++) {
        if(!visited[v]) {
            DFS(G, v);  // 对尚未访问的顶点调用DFS
        }
    }
}

/*
 * ████████ 算法7.5 ████████
 *
 * 深度优先遍历核心函数
 */
static void DFS(MGraph G, int v) {
    int w;

    // 从第v个顶点出发递归地深度优先遍历图G
    visited[v] = TRUE;

    // 访问第v个顶点
    VisitFunc(G.vexs[v]);

    for(w = FirstAdjVex(G, G.vexs[v]);
        w >= 0;
        w = NextAdjVex(G, G.vexs[v], G.vexs[w])) {
        if(!visited[w]) {
            DFS(G, w);  // 对尚未访问的顶点调用DFS
        }
    }
}

/*
 * ████████ 算法7.6 ████████
 *
 * 广度优先遍历(此处借助队列实现)
 */
void BFSTraverse(MGraph G, Status(Visit)(VertexType)) {
    int v, w;
    LinkQueue Q;
    QElemType u;

    // 初始化为未访问
    for(v = 0; v < G.vexnum; v++) {
        visited[v] = FALSE;
    }

    // 置空辅助队列
    InitQueue(&Q);

    for(v = 0; v < G.vexnum; v++) {
        // 如果该顶点已访问过，则直接忽略
        if(visited[v]) {
            continue;
        }

        // 标记该顶点已访问
        visited[v] = TRUE;

        // 访问顶点
        Visit(G.vexs[v]);

        EnQueue(&Q, v);

        while(!QueueEmpty(Q)) {
            DeQueue(&Q, &u);

            // 先集中访问顶点v的邻接顶点，随后再访问邻接顶点的邻接顶点
            for(w = FirstAdjVex(G, G.vexs[u]);
                w >= 0;
                w = NextAdjVex(G, G.vexs[u], G.vexs[w])) {
                if(!visited[w]) {
                    visited[w] = TRUE;
                    Visit(G.vexs[w]);
                    EnQueue(&Q, w);
                }
            }
        }
    }
}

/*
 * 以图形化形式输出当前结构
 *
 * 注：在图/网中，使用"-"来表示两顶点不直接连通
 */
void PrintGraph(MGraph G) {
    int i, j;

    if(G.vexnum == 0) {
        printf("空图，无需打印！\n");
        return;
    }

    printf("当前图/网包含 %2d 个顶点， %2d 条边/弧...\n", G.vexnum, G.arcnum);

    printf("  ");
    for(i = 0; i < G.vexnum; i++) {
        printf("  %c", G.vexs[i]);
    }
    printf("\n");

    for(i = 0; i < G.vexnum; i++) {
        printf("%c ", G.vexs[i]);

        for(j = 0; j < G.vexnum; j++) {
            if(((G.kind == DG || G.kind == UDG) && G.arcs[i][j].adj == 0) || ((G.kind == DN || G.kind == UDN) && G.arcs[i][j].adj == INFINITE)) {
                printf("  -");
            } else {
                printf("%3d", G.arcs[i][j].adj);
            }
        }

        printf("\n");
    }
}

邻接表

// 图的类型
typedef enum {
    DG,     // 0-有向图
    DN,     // 1-有向网(带权值)
    UDG,    // 2-无向图
    UDN     // 3-无向网(带权值)
} GraphKind;

// 顶点类型
typedef char VertexType;

// 边/弧的相关附加信息
typedef struct {
    /*
     * 注：
     * 教材中给出的结构只考虑了无权图，而没考虑有权图(网)。
     * 这里为了把“网”的情形也考虑进去，特在附加信息中增加了"权重"属性。
     */
    int weight;
} InfoType;

/* 边/弧结点 */
typedef struct ArcNode {
    int adjvex;                 // 该弧所指向的顶点的位置
    struct ArcNode* nextarc;    // 指向下一条弧的指针
    InfoType* info;             // 弧的附加信息，通常忽略
} ArcNode;

// 每个链表的头结点
typedef struct VNode {
    VertexType data;    // 顶点信息
    ArcNode* firstarc;  // 指向第一条依附该顶点的弧的指针
} VNode;

/* 图的邻接表存储表示类型定义 */
typedef struct {
    VNode vertices[MAX_VERTEX_NUM]; // 邻接表
    int vexnum, arcnum;             // 图/网的顶点数和弧数
    GraphKind kind;                 // 图的类型标志
} ALGraph;

/*
 * IncInfo指示该图/网的边/弧上是否存在附加信息。
 * 如果其值不为0，则表示无附加信息，否则，表示存在附加信息。
 */
Boolean IncInfo = FALSE;

// 访问标志数组，记录访问过的顶点
static Boolean visited[MAX_VERTEX_NUM];

// 函数变量
static Status (* VisitFunc)(VertexType e);


/*
 * 创建
 *
 *【备注】
 *
 * 教材中默认从控制台读取数据。
 * 这里为了方便测试，避免每次运行都手动输入数据，
 * 因而允许选择从预设的文件path中读取测试数据。
 *
 * 如果需要从控制台读取数据，则path为NULL，或path[kind]为""。
 * 如果需要从文件中读取数据，则需要在path中填写文件名信息。
 */
Status CreateGraph(ALGraph* G, char* path[]) {
    int readFromConsole;    // 是否从控制台读取数据
    int kind;
    Status flag;

    printf("请输入图的类型(0-有向图 │ 1-有向网 │ 2-无向图 │ 3-无向网)：");
    scanf("%d", &kind);

    // 类型不合规
    if(kind < 0 || kind > 3) {
        return ERROR;
    }

    // 如果没有文件路径信息，则从控制台读取输入
    readFromConsole = (path == NULL) || strcmp(path[kind], "") == 0;

    // 需要从文件读取
    if(readFromConsole) {
        (*G).kind = kind;   // 记录图/网的类型
    } else {
        // 打开文件，准备读取测试数据
        fp = fopen(path[kind], "r");
        if(fp == NULL) {
            return ERROR;
        }

        // 录入图的类型
        ReadData(fp, "%d", &((*G).kind));
    }

    // 随机创建有向图/网或无向图/网的一种
    switch((*G).kind) {
        case DG:
            flag = CreateDG(G);
            break;
        case DN:
            flag = CreateDN(G);
            break;
        case UDG:
            flag = CreateUDG(G);
            break;
        case UDN:
            flag = CreateUDN(G);
            break;
        default:
            flag = ERROR;
            break;
    }

    if(fp != NULL) {
        fclose(fp);
        fp = NULL;
    }

    return flag;
}

/*
 * 构造有向图
 */
static Status CreateDG(ALGraph* G) {
    int i, k;
    int vexnum, arcnum;
    VertexType v1, v2;
    InfoType* info = NULL;

    (*G).vexnum = (*G).arcnum = 0;

    if(fp == NULL) {
        printf("请输入有向图的顶点数：");
        scanf("%d", &vexnum);
        printf("请输入有向图的弧数：");
        scanf("%d", &arcnum);
        printf("该有向图的弧上是否包含其他附加信息(0-不包含│1-包含)：");
        scanf("%d", &IncInfo);

        // 录入顶点集
        printf("请录入 %d 个顶点，不同顶点之间用空格隔开：", vexnum);
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(stdin);
            scanf("%c", &((*G).vertices[i].data));
            (*G).vertices[i].firstarc = NULL;
            (*G).vexnum++;
        }
    } else {
        ReadData(fp, "%d", &vexnum);    // 录入顶点数
        ReadData(fp, "%d", &arcnum);    // 录入弧数
        ReadData(fp, "%d", &IncInfo);   // 判断弧上是否包含附加信息

        // 录入顶点集
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(fp);
            ReadData(fp, "%c", &((*G).vertices[i].data));
            (*G).vertices[i].firstarc = NULL;
            (*G).vexnum++;
        }
    }

    // 仅在控制台录入信息时输出此提示
    if(fp == NULL && arcnum != 0) {
        printf("请为有向图依次录入 %d 条弧的信息，顶点之间用空格隔开：\n", arcnum);
    }

    // 录入弧的信息
    for(k = 0; k < arcnum; k++) {
        if(fp == NULL) {
            printf("第 %2d 条弧：", k + 1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v2);
        } else {
            // 跳过空白，寻找下一个可读符号
            skipBlank(fp);
            ReadData(fp, "%c%c", &v1, &v2);
        }

        // 如果需要录入弧的其他附加信息
        if(IncInfo) {
            // 最后录入附加信息
            Input(*G, &info);
        }

        // 插入弧<v1, v2>
        InsertArc(G, v1, v2, info);
    }

    // 从文件中读取数据时，最后其实应当判断一下是否读到了足够的信息
    return OK;
}

/*
 * 构造有向网
 */
static Status CreateDN(ALGraph* G) {
    int i, k;
    int vexnum, arcnum;
    VertexType v1, v2;
    InfoType* info = NULL;

    (*G).vexnum = (*G).arcnum = 0;

    if(fp == NULL) {
        printf("请输入有向网的顶点数：");
        scanf("%d", &vexnum);
        printf("请输入有向网的弧数：");
        scanf("%d", &arcnum);
        printf("该有向网的弧上必须包含其他附加信息，因为此处的权值需要存储到附加信息中...\n");
        IncInfo = 1;

        // 录入顶点集
        printf("请录入 %d 个顶点，不同顶点之间用空格隔开：", vexnum);
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(stdin);
            scanf("%c", &((*G).vertices[i].data));
            (*G).vertices[i].firstarc = NULL;
            (*G).vexnum++;
        }
    } else {
        ReadData(fp, "%d", &vexnum); // 录入顶点数
        ReadData(fp, "%d", &arcnum); // 录入弧数
        ReadData(fp, "%d", &IncInfo);// 判断弧上是否包含附加信息(此处应当包含)
        IncInfo = 1;    // 强制将权值录入到附加信息中

        // 录入顶点集
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(fp);
            ReadData(fp, "%c", &((*G).vertices[i].data));
            (*G).vertices[i].firstarc = NULL;
            (*G).vexnum++;
        }
    }

    // 仅在控制台录入信息时输出此提示
    if(fp == NULL && arcnum != 0) {
        printf("请为有向网依次录入 %d 条弧(带权值)的信息，顶点及权值之间用空格隔开：\n", arcnum);
    }

    // 录入弧的信息
    for(k = 0; k < arcnum; k++) {
        if(fp == NULL) {
            printf("第 %2d 条弧及其权值：", k + 1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v2);
        } else {
            // 跳过空白，寻找下一个可读符号
            skipBlank(fp);
            ReadData(fp, "%c%c", &v1, &v2);
        }

        // 如果需要录入弧的其他附加信息
        if(IncInfo) {
            // 最后录入附加信息(此处需要录入网的权值)
            Input(*G, &info);
        }

        // 插入弧<v1, v2>
        InsertArc(G, v1, v2, info);
    }

    // 从文件中读取数据时，最后其实应当判断一下是否读到了足够的信息
    return OK;
}

/*
 * 构造无向图
 */
static Status CreateUDG(ALGraph* G) {
    int i, k;
    int vexnum, arcnum;
    VertexType v1, v2;
    InfoType* info = NULL;

    (*G).vexnum = (*G).arcnum = 0;

    if(fp == NULL) {
        printf("请输入无向图的顶点数：");
        scanf("%d", &vexnum);
        printf("请输入无向图的边数：");
        scanf("%d", &arcnum);
        printf("该无向图的边上是否包含其他附加信息(0-不包含│1-包含)：");
        scanf("%d", &IncInfo);

        // 录入顶点集
        printf("请录入 %d 个顶点，不同顶点之间用空格隔开：", vexnum);
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(stdin);
            scanf("%c", &((*G).vertices[i].data));
            (*G).vertices[i].firstarc = NULL;
            (*G).vexnum++;
        }
    } else {
        ReadData(fp, "%d", &vexnum); // 录入顶点数
        ReadData(fp, "%d", &arcnum); // 录入边数
        ReadData(fp, "%d", &IncInfo);// 判断边上是否包含附加信息

        // 录入顶点集
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(fp);
            ReadData(fp, "%c", &((*G).vertices[i].data));
            (*G).vertices[i].firstarc = NULL;
            (*G).vexnum++;
        }
    }

    // 仅在控制台录入信息时输出此提示
    if(fp == NULL && arcnum != 0) {
        printf("请为无向图依次录入 %d 条边的信息，顶点之间用空格隔开：\n", arcnum);
    }

    // 录入边的信息
    for(k = 0; k < arcnum; k++) {
        if(fp == NULL) {
            printf("第 %2d 条边：", k + 1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v2);
        } else {
            // 跳过空白，寻找下一个可读符号
            skipBlank(fp);
            ReadData(fp, "%c%c", &v1, &v2);
        }

        // 如果需要录入边的其他附加信息
        if(IncInfo) {
            // 最后录入附加信息
            Input(*G, &info);

        }

        // 插入边<v1, v2>
        InsertArc(G, v1, v2, info);
    }

    // 从文件中读取数据时，最后其实应当判断一下是否读到了足够的信息
    return OK;
}

/*
 * 构造无向网
 */
static Status CreateUDN(ALGraph* G) {
    int i, k;
    int vexnum, arcnum;
    VertexType v1, v2;
    InfoType* info = NULL;

    (*G).vexnum = (*G).arcnum = 0;

    if(fp == NULL) {
        printf("请输入无向网的顶点数：");
        scanf("%d", &vexnum);
        printf("请输入无向网的边数：");
        scanf("%d", &arcnum);
        printf("该无向网的边上必须包含其他附加信息，因为此处的权值需要存储到附加信息中...\n");
        IncInfo = 1;

        // 录入顶点集
        printf("请录入 %d 个顶点，不同顶点之间用空格隔开：", vexnum);
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(stdin);
            scanf("%c", &((*G).vertices[i].data));
            (*G).vertices[i].firstarc = NULL;
            (*G).vexnum++;
        }
    } else {
        ReadData(fp, "%d", &vexnum); // 录入顶点数
        ReadData(fp, "%d", &arcnum); // 录入边数
        ReadData(fp, "%d", &IncInfo);// 判断边上是否包含附加信息
        IncInfo = 1;    // 强制将权值录入到附加信息中

        // 录入顶点集
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(fp);
            ReadData(fp, "%c", &((*G).vertices[i].data));
            (*G).vertices[i].firstarc = NULL;
            (*G).vexnum++;
        }
    }

    // 仅在控制台录入信息时输出此提示
    if(fp == NULL && arcnum != 0) {
        printf("请为无向网依次录入 %d 条边(带权值)的信息，顶点及权值之间用空格隔开：\n", arcnum);
    }

    // 录入边的信息
    for(k = 0; k < arcnum; k++) {
        if(fp == NULL) {
            printf("第 %2d 条边及其权值：", k + 1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v2);
        } else {
            // 跳过空白，寻找下一个可读符号
            skipBlank(fp);
            ReadData(fp, "%c%c", &v1, &v2);
        }

        // 如果需要录入边的其他附加信息
        if(IncInfo) {
            // 最后录入附加信息(此处需要录入网的权值)
            Input(*G, &info);
        }

        // 插入边<v1, v2>
        InsertArc(G, v1, v2, info);
    }

    // 从文件中读取数据时，最后其实应当判断一下是否读到了足够的信息
    return OK;
}

/*
 * 录入边/弧的相关附加信息
 */
static void Input(ALGraph G, InfoType** info) {
    int weight;

    // 在"网"的情形下需要录入权值信息
    if(G.kind == DN || G.kind == UDN) {
        *info = (InfoType*) malloc(sizeof(InfoType));

        if(fp == NULL) {
            scanf("%d", &weight);
        } else {
            ReadData(fp, "%d", &weight);
        }

        (*info)->weight = weight;
    }
}

/*
 * 销毁
 *
 * 邻接表存储的图需要释放内存。
 */
Status DestroyGraph(ALGraph* G) {
    int k;
    ArcNode* pre, * r;

    for(k = 0; k < G->vexnum; k++) {
        r = G->vertices[k].firstarc;

        while(r != NULL) {
            pre = r;
            r = r->nextarc;
            free(pre);
        }

        G->vertices[k].firstarc = NULL;
    }

    (*G).vexnum = 0;
    (*G).arcnum = 0;
    IncInfo = 0;

    return OK;
}

/*
 * 查找
 *
 * 返回顶点u在图/网中的位置
 */
int LocateVex(ALGraph G, VertexType u) {
    int i;

    for(i = 0; i < G.vexnum; i++) {
        if(G.vertices[i].data == u) {
            return i;
        }
    }

    return -1;
}

/*
 * 取值
 *
 * 返回索引v处的顶点值
 */
VertexType GetVex(ALGraph G, int v) {
    if(v < 0 || v >= G.vexnum) {
        return '\0';    // 指定的顶点不存在
    }

    return G.vertices[v].data;
}

/*
 * 赋值
 *
 * 将顶点v赋值为value
 */
Status PutVex(ALGraph* G, VertexType v, VertexType value) {
    int k;

    // 首先需要判断该顶点是否存在
    k = LocateVex((*G), v);
    if(k == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    // 替换头结点
    (*G).vertices[k].data = value;

    /* 链表中的元素存储的是顶点的位置，所以无需遍历链表来替换目标值 */

    return OK;
}

/*
 * 首个邻接点
 *
 * 返回顶点v的首个邻接点
 */
int FirstAdjVex(ALGraph G, VertexType v) {
    int k;
    ArcNode* r;

    // 首先需要判断该顶点是否存在
    k = LocateVex(G, v);
    if(k == -1) {
        return -1;    // 指定的顶点不存在
    }

    r = G.vertices[k].firstarc;
    if(r == NULL) {
        return -1;
    } else {
        return r->adjvex;
    }
}

/*
 * 下一个邻接点
 *
 * 返回顶点v的(相对于w的)下一个邻接点
 */
int NextAdjVex(ALGraph G, VertexType v, VertexType w) {
    int kv, kw;
    ArcNode* r;

    // 首先需要判断该顶点是否存在
    kv = LocateVex(G, v);
    if(kv == -1) {
        return -1;    // 指定的顶点不存在
    }

    // 首先需要判断该顶点是否存在
    kw = LocateVex(G, w);
    if(kw == -1) {
        return -1;    // 指定的顶点不存在
    }

    r = G.vertices[kv].firstarc;
    if(r == NULL) {
        return -1;  // 链表为空
    }

    // 在链表中查找w
    while(r != NULL && r->adjvex < kw) {
        r = r->nextarc;
    }

    // 如果没找到w
    if(r == NULL) {
        return -1;
    }

    // 如果找到了w，但是w后面没有别的顶点，那么也无法返回邻接点
    if(r->adjvex == kw && r->nextarc != NULL) {
        return r->nextarc->adjvex;
    }

    return -1;
}

/*
 * 插入顶点
 *
 * 将指定的顶点v追加到顶点集中，未建立该顶点与其他顶点的关系
 */
Status InsertVex(ALGraph* G, VertexType v) {
    int k;

    // 顶点数过多
    if((*G).vexnum == MAX_VERTEX_NUM) {
        return ERROR;
    }

    // 首先需要判断该顶点是否存在
    k = LocateVex(*G, v);
    if(k >= 0) {
        return ERROR;    // 指定的顶点存在时，无需重复添加
    }

    G->vertices[(*G).vexnum].data = v;
    G->vertices[(*G).vexnum].firstarc = NULL;

    (*G).vexnum++;

    return OK;
}

/*
 * 删除顶点
 *
 * 从顶点集中删除指定的顶点v，注意需要更新相关的顶点关系
 */
Status DeleteVex(ALGraph* G, VertexType v) {
    int k, i;
    ArcNode* pre, * r;

    // 首先需要判断该顶点是否存在
    k = LocateVex(*G, v);
    if(k == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    // 找到以结点v出发的链表，释放该链表上所有结点
    r = G->vertices[k].firstarc;
    while(r != NULL) {
        pre = r;
        r = r->nextarc;
        free(pre);

        (*G).arcnum--;
    }

    G->vertices[k].firstarc = NULL;

    // 遍历其它所有链表，删除那些指向顶点v的弧；而且，下标超过k的顶点，其下标值需要递减
    for(i = 0; i < G->vexnum; i++) {
        pre = NULL;
        r = G->vertices[i].firstarc;
        while(r != NULL && r->adjvex < k) {
            pre = r;
            r = r->nextarc;
        }

        // 链表上所有顶点的下标均小于k
        if(r == NULL) {
            continue;
        }

        if(r->adjvex == k) {
            // 从开头删掉结点v
            if(pre == NULL) {
                G->vertices[i].firstarc = r->nextarc;

                // 从中间某个位置删掉结点v
            } else {
                pre->nextarc = r->nextarc;
            }

            free(r);

            // 如果这是有向的图/网，依然需要递减边/弧的数量
            if((*G).kind == DG || (*G).kind == DN) {
                (*G).arcnum--;
            }
        }

        // 再次确定r的位置
        if(pre == NULL) {
            r = G->vertices[i].firstarc;
        } else {
            r = pre->nextarc;
        }

        // 下标超过k的顶点，需要递减其下标
        while(r != NULL && r->adjvex > k) {
            r->adjvex -= 1;
            r = r->nextarc;
        }
    }

    // 顶点集前移
    for(i = k + 1; i < (*G).vexnum; i++) {
        G->vertices[i - 1] = G->vertices[i];
    }

    // 顶点数递减
    (*G).vexnum--;

    return OK;
}

/*
 * 构造一个边/弧结点(仅限内部使用)
 */
static ArcNode* newArcNodePtr(int adjvex, ArcNode* nextarc, InfoType* info) {
    ArcNode* p = (ArcNode*) malloc(sizeof(ArcNode));
    if(!p) {
        exit(OVERFLOW);
    }

    p->adjvex = adjvex;

    p->nextarc = nextarc;

    p->info = info;

    return p;
}

/*
 * 插入边/弧<v, w>
 *
 * 如果当前图/网是无向的，则插入一条弧需要增加两个顶点关系，但弧的数量只增一。
 * 对于图/网来说，可以在可变参数中列出边/弧的附加信息。
 *
 * 注：此处接收的参数与MGraph有些不一样：网的附加信息中包含了各条边/弧的权值。
 */
Status InsertArc(ALGraph* G, VertexType v, VertexType w, ...) {
    int tail, head, k, count;
    ArcNode* r;
    ArcNode* pre;
    Boolean overlay = FALSE;    // 是否为覆盖添加
    InfoType* info = NULL;      // 边/弧的附加信息
    va_list ap;

    tail = LocateVex(*G, v); // 获取顶点v在顶点集中的位置
    if(tail == -1) {
        return ERROR;  // 指定的顶点不存在
    }

    head = LocateVex(*G, w); // 获取顶点w在顶点集中的位置
    if(head == -1) {
        return ERROR;  // 指定的顶点不存在
    }

    // 拒绝环
    if(tail == head) {
        return ERROR;
    }

    // 如果边/弧上存在附加信息
    if(IncInfo) {
        va_start(ap, w);                // 在w后查询首个可变参数
        info = va_arg(ap, InfoType*);   // 获取附加信息
        va_end(ap);
    }

    /* 接下来，需要查找合适的插入位置 */

    for(count = 0; count < 2; count++) {
        pre = NULL;
        // 指向以tail为尾的首条边/弧
        r = G->vertices[tail].firstarc;
        while(r != NULL && r->adjvex < head) {
            pre = r;
            r = r->nextarc;
        }

        // 遇到了相同位置的结点
        if(r != NULL && r->adjvex == head) {
            r->info = info; // 复用该结点
            overlay = TRUE; // 发生了覆盖
        } else {
            if(pre == NULL) {
                G->vertices[tail].firstarc = newArcNodePtr(head, r, info);
            } else {
                pre->nextarc = newArcNodePtr(head, r, info);
            }
        }

        // 如果当前图/网是无向的，需要考虑对称性
        if((G->kind == UDG || G->kind == UDN) && tail != head) {
            // 颠倒i和j
            k = tail;
            tail = head;
            head = k;
        } else {
            break;  // 如果是有向的，可以结束了
        }
    }

    // 在非覆盖的情形下，才考虑更新边/弧的数量
    if(!overlay) {
        (*G).arcnum++;  // 不论有向无向，边/弧数只增一
    }

    return OK;
}

/*
 * 删除边/弧<v, w>
 */
Status DeleteArc(ALGraph* G, VertexType v, VertexType w) {
    int tail, head, k, count;
    ArcNode* r;
    ArcNode* pre;

    tail = LocateVex(*G, v);
    if(tail == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    head = LocateVex(*G, w);
    if(head == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    for(count = 0; count < 2; count++) {
        pre = NULL;
        // 在当前链表中找到待删除的边/弧
        r = G->vertices[tail].firstarc;
        while(r != NULL && r->adjvex < head) {
            pre = r;
            r = r->nextarc;
        }

        // 找到了待删除的边/弧
        if(r != NULL && r->adjvex == head) {
            if(pre == NULL) {
                G->vertices[tail].firstarc = r->nextarc;
            } else {
                pre->nextarc = r->nextarc;
            }

            free(r);
        } else {
            return ERROR; // 没找到
        }

        // 如果当前图/网是无向的，需要考虑对称性
        if((G->kind == UDG || G->kind == UDN) && tail != head) {
            // 颠倒tail和head
            k = tail;
            tail = head;
            head = k;
        } else {
            break;  // 如果是有向的，可以结束了
        }
    }

    (*G).arcnum--;  // 不论有向无向，边/弧数只减一

    return OK;
}

/*
 * 深度优先遍历(此处借助递归实现)
 */
void DFSTraverse(ALGraph G, Status(Visit)(VertexType)) {
    int v;

    // 使用全局变量VisitFunc，使得DFS不必设置函数指针参数
    VisitFunc = Visit;

    // 访问标志数组初始化
    for(v = 0; v < G.vexnum; v++) {
        visited[v] = FALSE;
    }

    // 此处需要遍历的原因是并不能保证所有顶点都连接在了一起
    for(v = 0; v < G.vexnum; v++) {
        if(!visited[v]) {
            DFS(G, v);  // 对尚未访问的顶点调用DFS
        }
    }
}

/*
 * 深度优先遍历核心函数
 */
static void DFS(ALGraph G, int v) {
    int w;

    // 从第v个顶点出发递归地深度优先遍历图G
    visited[v] = TRUE;

    // 访问第v个顶点
    VisitFunc(G.vertices[v].data);

    for(w = FirstAdjVex(G, G.vertices[v].data);
        w >= 0;
        w = NextAdjVex(G, G.vertices[v].data, G.vertices[w].data)) {
        if(!visited[w]) {
            DFS(G, w);  // 对尚未访问的顶点调用DFS
        }
    }
}

/*
 * 广度优先遍历(此处借助队列实现)
 */
void BFSTraverse(ALGraph G, Status(Visit)(VertexType)) {
    int v, w;
    LinkQueue Q;
    QElemType u;

    // 初始化为未访问
    for(v = 0; v < G.vexnum; v++) {
        visited[v] = FALSE;
    }

    // 置空辅助队列
    InitQueue(&Q);

    for(v = 0; v < G.vexnum; v++) {
        // 如果该顶点已访问过，则直接忽略
        if(visited[v]) {
            continue;
        }

        // 标记该顶点已访问
        visited[v] = TRUE;

        // 访问顶点
        Visit(G.vertices[v].data);

        EnQueue(&Q, v);

        while(!QueueEmpty(Q)) {
            DeQueue(&Q, &u);

            // 先集中访问顶点v的邻接顶点，随后再访问邻接顶点的邻接顶点
            for(w = FirstAdjVex(G, G.vertices[u].data);
                w >= 0;
                w = NextAdjVex(G, G.vertices[u].data, G.vertices[w].data)) {
                if(!visited[w]) {
                    visited[w] = TRUE;
                    Visit(G.vertices[w].data);
                    EnQueue(&Q, w);
                }
            }
        }
    }
}

/*
 * 以图形化形式输出当前结构
 */
void PrintGraph(ALGraph G) {
    int i;
    ArcNode* p;

    if(G.vexnum == 0) {
        printf("空图，无需打印！\n");
        return;
    }

    printf("当前图/网包含 %2d 个顶点， %2d 条边/弧...\n", G.vexnum, G.arcnum);

    for(i = 0; i < G.vexnum; i++) {
        printf("%c ===> ", G.vertices[i].data);

        p = G.vertices[i].firstarc;
        while(p != NULL) {
            if(IncInfo == 0) {
                printf("%c ", G.vertices[p->adjvex].data);

                // 对于网，会从其附加信息中获取到权值
            } else {
                printf("%c[%2d] ", G.vertices[p->adjvex].data, p->info->weight);
            }

            p = p->nextarc;

            if(p != NULL) {
                printf("- ");
            }
        }

        printf("\n");
    }
}

// 图的类型
typedef enum {
    DG,     // 0-有向图
    DN,     // 1-有向网(带权值)
    UDG,    // 2-无向图
    UDN     // 3-无向网(带权值)
} GraphKind;

// 顶点类型
typedef char VertexType;

// 边/弧的相关附加信息
typedef struct {
    /*
     * 注：
     * 教材中给出的结构只考虑了无权图，而没考虑有权图(网)。
     * 这里为了把“网”的情形也考虑进去，特在附加信息中增加了"权重"属性。
     */
    int weight;
} InfoType;

/* 边/弧结点 */
typedef struct ArcBox {
    int tailvex;    // 弧头顶点位置
    int headvex;    // 弧尾顶点位置
    struct ArcBox* hlink;  // 指向下一个拥有相同弧头的弧
    struct ArcBox* tlink;  // 指向下一个拥有相同弧尾的弧
    InfoType* info;  // 该弧的相关附加信息
} ArcBox;

// 每个横向链表的头结点
typedef struct VexNode {
    VertexType data;    // 顶点
    ArcBox* firstin;    // 指向该顶点的第一条入弧
    ArcBox* firstout;   // 指向该顶点的第一条出弧
} VexNode;

/* 图的十字链表存储表示类型定义 */
typedef struct {
    VexNode xlist[MAX_VERTEX_NUM];  // 表头向量
    int vexnum, arcnum;             // 顶点数和弧数
    GraphKind kind;                 // 图的类型标志
} OLGraph;


// 边/弧上是否存在附加信息
extern Boolean IncInfo;

// 录入数据的源文件；fp为null时，说明需要从控制台录入
static FILE* fp = NULL;

/*
 * IncInfo指示该图的边上是否存在附加信息。
 * 如果其值不为0，则表示无附加信息，否则，表示存在附加信息。
 */
Boolean IncInfo = FALSE;

// 访问标志数组，记录访问过的顶点
static Boolean visited[MAX_VERTEX_NUM];

// 函数变量
static Status (* VisitFunc)(VertexType e);


/*
 * 创建
 *
 *【备注】
 *
 * 教材中默认从控制台读取数据。
 * 这里为了方便测试，避免每次运行都手动输入数据，
 * 因而允许选择从预设的文件path中读取测试数据。
 *
 * 如果需要从控制台读取数据，则path为NULL，或path[kind]为""。
 * 如果需要从文件中读取数据，则需要在path中填写文件名信息。
 */
Status CreateGraph(OLGraph* G, char* path[]) {
    int readFromConsole;    // 是否从控制台读取数据
    int kind;
    Status flag;

    printf("请输入图的类型(0-有向图 │ 1-有向网 │ 2-无向图 │ 3-无向网)：");
    scanf("%d", &kind);

    // 类型不合规
    if(kind < 0 || kind > 3) {
        return ERROR;
    }

    // 如果没有文件路径信息，则从控制台读取输入
    readFromConsole = (path == NULL) || strcmp(path[kind], "") == 0;

    // 需要从文件读取
    if(readFromConsole) {
        (*G).kind = kind;   // 记录图/网的类型
    } else {
        // 打开文件，准备读取测试数据
        fp = fopen(path[kind], "r");
        if(fp == NULL) {
            return ERROR;
        }

        // 录入图的类型
        ReadData(fp, "%d", &((*G).kind));
    }

    // 随机创建有向图/网或无向图/网的一种
    switch((*G).kind) {
        case DG:
            flag = CreateDG(G);
            break;
        case DN:
            flag = CreateDN(G);
            break;
        case UDG:
            flag = CreateUDG(G);
            break;
        case UDN:
            flag = CreateUDN(G);
            break;
        default:
            flag = ERROR;
            break;
    }

    if(fp != NULL) {
        fclose(fp);
        fp = NULL;
    }

    return flag;
}

/*
 * ████████ 算法7.3 ████████
 *
 * 构造有向图
 *
 * 注：
 * 教材中使用了头插法来插入弧，这种做法的唯一优点是插入方便，
 * 但是在涉及到删除或查找时，效率较低；
 * 而且，"头插法"依赖输入的顺序，如果输入的边/弧是乱序的，
 * 则最终构造出的图/网中的边/弧也是无序的。
 *
 * 为了克服以上缺点，这里改用"升序"插入法，保证插入的弧是"升序"的。
 * 但同时，这样做会使"插入"算法变得较为复杂。
 */
static Status CreateDG(OLGraph* G) {
    int i, k;
    int vexnum, arcnum;
    VertexType v1, v2;
    InfoType* info = NULL;

    (*G).vexnum = (*G).arcnum = 0;

    if(fp == NULL) {
        printf("请输入有向图的顶点数：");
        scanf("%d", &vexnum);
        printf("请输入有向图的弧数：");
        scanf("%d", &arcnum);
        printf("该有向图的弧上是否包含其他附加信息(0-不包含│1-包含)：");
        scanf("%d", &IncInfo);

        // 录入顶点集
        printf("请录入 %d 个顶点，不同顶点之间用空格隔开：", vexnum);
        for(i = 0; i < vexnum; i++) {
            scanf("%c", &((*G).xlist[i].data));
            (*G).xlist[i].firstin = NULL;
            (*G).xlist[i].firstout = NULL;
            (*G).vexnum++;
        }
    } else {
        ReadData(fp, "%d", &vexnum);    // 录入顶点数
        ReadData(fp, "%d", &arcnum);    // 录入弧数
        ReadData(fp, "%d", &IncInfo);   // 判断弧上是否包含附加信息

        // 录入顶点集
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(fp);
            ReadData(fp, "%c", &((*G).xlist[i].data));
            (*G).xlist[i].firstin = NULL;
            (*G).xlist[i].firstout = NULL;
            (*G).vexnum++;
        }
    }

    // 仅在控制台录入信息时输出此提示
    if(fp == NULL && arcnum != 0) {
        printf("请为有向图依次录入 %d 条弧的信息，顶点之间用空格隔开：\n", arcnum);
    }

    // 录入弧的信息
    for(k = 0; k < arcnum; k++) {
        if(fp == NULL) {
            printf("第 %2d 条弧：", k + 1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v2);
        } else {
            // 跳过空白，寻找下一个可读符号
            skipBlank(fp);
            ReadData(fp, "%c%c", &v1, &v2);
        }

        // 如果需要录入弧的其他附加信息
        if(IncInfo) {
            // 最后录入附加信息
            Input(*G, &info);
        }

        // 插入弧<v1, v2>
        InsertArc(G, v1, v2, info);
    }

    // 从文件中读取数据时，最后其实应当判断一下是否读到了足够的信息
    return OK;
}

/*
 * 构造有向网
 */
static Status CreateDN(OLGraph* G) {
    int i, k;
    int vexnum, arcnum;
    VertexType v1, v2;
    InfoType* info = NULL;

    (*G).vexnum = (*G).arcnum = 0;

    if(fp == NULL) {
        printf("请输入有向图的顶点数：");
        scanf("%d", &vexnum);
        printf("请输入有向网的弧数：");
        scanf("%d", &arcnum);
        printf("该有向网的弧上必须包含其他附加信息，因为此处的权值需要存储到附加信息中...\n");
        IncInfo = 1;

        // 录入顶点集
        printf("请录入 %d 个顶点，不同顶点之间用空格隔开：", vexnum);
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(stdin);
            scanf("%c", &((*G).xlist[i].data));
            (*G).xlist[i].firstin = NULL;
            (*G).xlist[i].firstout = NULL;
            (*G).vexnum++;
        }
    } else {
        ReadData(fp, "%d", &vexnum); // 录入顶点数
        ReadData(fp, "%d", &arcnum); // 录入弧数
        ReadData(fp, "%d", &IncInfo);// 判断弧上是否包含附加信息(此处应当包含)
        IncInfo = 1;    // 强制将权值录入到附加信息中

        // 录入顶点集
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(fp);
            ReadData(fp, "%c", &((*G).xlist[i].data));
            (*G).xlist[i].firstin = NULL;
            (*G).xlist[i].firstout = NULL;
            (*G).vexnum++;
        }
    }

    // 仅在控制台录入信息时输出此提示
    if(fp == NULL && arcnum != 0) {
        printf("请为有向网依次录入 %d 条弧(带权值)的信息，顶点及权值之间用空格隔开：\n", arcnum);
    }

    // 录入弧的信息
    for(k = 0; k < arcnum; k++) {
        if(fp == NULL) {
            printf("第 %2d 条弧及其权值：", k + 1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v2);
        } else {
            // 跳过空白，寻找下一个可读符号
            skipBlank(fp);
            ReadData(fp, "%c%c", &v1, &v2);
        }

        // 如果需要录入弧的其他附加信息
        if(IncInfo) {
            // 最后录入附加信息(此处需要录入网的权值)
            Input(*G, &info);
        }

        // 插入弧<v1, v2>
        InsertArc(G, v1, v2, info);
    }

    // 从文件中读取数据时，最后其实应当判断一下是否读到了足够的信息
    return OK;
}

/*
 * 构造无向图
 */
static Status CreateUDG(OLGraph* G) {
    int i, k;
    int vexnum, arcnum;
    VertexType v1, v2;
    InfoType* info = NULL;

    (*G).vexnum = (*G).arcnum = 0;

    if(fp == NULL) {
        printf("请输入无向图的顶点数：");
        scanf("%d", &vexnum);
        printf("请输入无向图的边数：");
        scanf("%d", &arcnum);
        printf("该无向图的边上是否包含其他附加信息(0-不包含│1-包含)：");
        scanf("%d", &IncInfo);

        // 录入顶点集
        printf("请录入 %d 个顶点，不同顶点之间用空格隔开：", vexnum);
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(stdin);
            scanf("%c", &((*G).xlist[i].data));
            (*G).xlist[i].firstin = NULL;
            (*G).xlist[i].firstout = NULL;
            (*G).vexnum++;
        }
    } else {
        ReadData(fp, "%d", &vexnum); // 录入顶点数
        ReadData(fp, "%d", &arcnum); // 录入边数
        ReadData(fp, "%d", &IncInfo);// 判断边上是否包含附加信息

        // 录入顶点集
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(fp);
            ReadData(fp, "%c", &((*G).xlist[i].data));
            (*G).xlist[i].firstin = NULL;
            (*G).xlist[i].firstout = NULL;
            (*G).vexnum++;
        }
    }

    // 仅在控制台录入信息时输出此提示
    if(fp == NULL && arcnum != 0) {
        printf("请为无向图依次录入 %d 条边的信息，顶点之间用空格隔开：\n", arcnum);
    }

    // 录入边的信息
    for(k = 0; k < arcnum; k++) {
        if(fp == NULL) {
            printf("第 %2d 条边：", k + 1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v2);
        } else {
            // 跳过空白，寻找下一个可读符号
            skipBlank(fp);
            ReadData(fp, "%c%c", &v1, &v2);
        }

        // 如果需要录入边的其他附加信息
        if(IncInfo) {
            // 最后录入附加信息
            Input(*G, &info);
        }

        // 插入边<v1, v2>
        InsertArc(G, v1, v2, info);
    }

    // 从文件中读取数据时，最后其实应当判断一下是否读到了足够的信息
    return OK;
}

/*
 * 构造无向网
 */
static Status CreateUDN(OLGraph* G) {
    int i, k;
    int vexnum, arcnum;
    VertexType v1, v2;
    InfoType* info = NULL;

    (*G).vexnum = (*G).arcnum = 0;

    if(fp == NULL) {
        printf("请输入无向网的顶点数：");
        scanf("%d", &vexnum);
        printf("请输入无向网的边数：");
        scanf("%d", &arcnum);
        printf("该无向网的边上必须包含其他附加信息，因为此处的权值需要存储到附加信息中...\n");
        IncInfo = 1;

        // 录入顶点集
        printf("请录入 %d 个顶点，不同顶点之间用空格隔开：", vexnum);
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(stdin);
            scanf("%c", &((*G).xlist[i].data));
            (*G).xlist[i].firstin = NULL;
            (*G).xlist[i].firstout = NULL;
            (*G).vexnum++;
        }
    } else {
        ReadData(fp, "%d", &vexnum); // 录入顶点数
        ReadData(fp, "%d", &arcnum); // 录入边数
        ReadData(fp, "%d", &IncInfo);// 判断边上是否包含附加信息
        IncInfo = 1;    // 强制将权值录入到附加信息中

        // 录入顶点集
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(fp);
            ReadData(fp, "%c", &((*G).xlist[i].data));
            (*G).xlist[i].firstin = NULL;
            (*G).xlist[i].firstout = NULL;
            (*G).vexnum++;
        }
    }

    // 仅在控制台录入信息时输出此提示
    if(fp == NULL && arcnum != 0) {
        printf("请为无向网依次录入 %d 条边(带权值)的信息，顶点及权值之间用空格隔开：\n", arcnum);
    }

    // 录入边的信息
    for(k = 0; k < arcnum; k++) {
        if(fp == NULL) {
            printf("第 %2d 条边及其权值：", k + 1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v2);
        } else {
            // 跳过空白，寻找下一个可读符号
            skipBlank(fp);
            ReadData(fp, "%c%c", &v1, &v2);
        }

        // 如果需要录入边的其他附加信息
        if(IncInfo) {
            // 最后录入附加信息(此处需要录入网的权值)
            Input(*G, &info);
        }

        // 插入边<v1, v2>
        InsertArc(G, v1, v2, info);
    }

    // 从文件中读取数据时，最后其实应当判断一下是否读到了足够的信息
    return OK;
}

/*
 * 录入弧的相关附加信息
 */
static void Input(OLGraph G, InfoType** info) {
    int weight;

    // 在"网"的情形下需要录入权值信息
    if(G.kind == DN || G.kind == UDN) {
        *info = (InfoType*) malloc(sizeof(InfoType));

        if(fp == NULL) {
            scanf("%d", &weight);
        } else {
            ReadData(fp, "%d", &weight);
        }

        (*info)->weight = weight;
    }
}

/*
 * 销毁
 *
 * 邻接表存储的图需要释放内存。
 */
Status DestroyGraph(OLGraph* G) {
    int k;
    ArcBox* pre, * r;

    for(k = 0; k < G->vexnum; k++) {
        r = G->xlist[k].firstout;

        while(r != NULL) {
            pre = r;
            r = r->tlink;
            free(pre);
        }

        G->xlist[k].firstin = NULL;
        G->xlist[k].firstout = NULL;
    }

    (*G).vexnum = 0;
    (*G).arcnum = 0;
    IncInfo = 0;

    return OK;
}

/*
 * 查找
 *
 * 返回顶点u在图/网中的位置
 */
int LocateVex(OLGraph G, VertexType u) {
    int i;

    for(i = 0; i < G.vexnum; i++) {
        if(G.xlist[i].data == u) {
            return i;
        }
    }

    return -1;
}

/*
 * 取值
 *
 * 返回索引v处的顶点值
 */
VertexType GetVex(OLGraph G, int v) {
    if(v < 0 || v >= G.vexnum) {
        return '\0';    // 指定的顶点不存在
    }

    return G.xlist[v].data;
}

/*
 * 赋值
 *
 * 将顶点v赋值为value
 */
Status PutVex(OLGraph* G, VertexType v, VertexType value) {
    int k;

    // 首先需要判断该顶点是否存在
    k = LocateVex((*G), v);
    if(k == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    // 替换头结点
    (*G).xlist[k].data = value;

    /* 链表中的元素存储的是顶点的位置，所以无需遍历链表来替换目标值 */

    return OK;
}

/*
 * 首个邻接点
 *
 * 返回顶点v的首个邻接点
 */
int FirstAdjVex(OLGraph G, VertexType v) {
    int k;
    ArcBox* r;

    // 首先需要判断该顶点是否存在
    k = LocateVex(G, v);
    if(k == -1) {
        return -1;    // 指定的顶点不存在
    }

    r = G.xlist[k].firstout;
    if(r == NULL) {
        return -1;
    } else {
        return r->headvex;
    }
}

/*
 * 下一个邻接点
 *
 * 返回顶点v的(相对于w的)下一个邻接点
 */
int NextAdjVex(OLGraph G, VertexType v, VertexType w) {
    int kv, kw;
    ArcBox* r;

    // 首先需要判断该顶点是否存在
    kv = LocateVex(G, v);
    if(kv == -1) {
        return -1;    // 指定的顶点不存在
    }

    // 首先需要判断该顶点是否存在
    kw = LocateVex(G, w);
    if(kw == -1) {
        return -1;    // 指定的顶点不存在
    }

    r = G.xlist[kv].firstout;
    if(r == NULL) {
        return -1;  // 链表为空
    }

    // 在链表中查找w
    while(r != NULL && r->headvex < kw) {
        r = r->tlink;
    }

    // 如果没找到w
    if(r == NULL) {
        return -1;
    }

    // 如果找到了w，但是w后面没有别的顶点，那么也无法返回邻接点
    if(r->headvex == kw && r->tlink != NULL) {
        return r->tlink->headvex;
    }

    return -1;
}

/*
 * 插入顶点
 *
 * 将指定的顶点v追加到顶点集中，未建立该顶点与其他顶点的关系
 */
Status InsertVex(OLGraph* G, VertexType v) {
    int k;

    // 顶点数过多
    if((*G).vexnum == MAX_VERTEX_NUM) {
        return ERROR;
    }

    // 首先需要判断该顶点是否存在
    k = LocateVex(*G, v);
    if(k >= 0) {
        return ERROR;    // 指定的顶点存在时，无需重复添加
    }

    G->xlist[(*G).vexnum].data = v;
    G->xlist[(*G).vexnum].firstin = NULL;
    G->xlist[(*G).vexnum].firstout = NULL;

    (*G).vexnum++;

    return OK;
}

/*
 * 删除顶点
 *
 * 从顶点集中删除指定的顶点v，注意需要更新相关的顶点关系
 */
Status DeleteVex(OLGraph* G, VertexType v) {
    int k, i;
    ArcBox* pre, * r;
    ArcBox* pre2, * r2;

    // 首先需要判断该顶点是否存在
    k = LocateVex(*G, v);
    if(k == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    // 找到以结点v出发的链表，释放该链表上所有结点
    r = G->xlist[k].firstout;
    while(r != NULL) {
        pre = r;
        r = r->tlink;

        // 在纵向链表上查找pre的位置
        pre2 = NULL;
        r2 = G->xlist[pre->headvex].firstin;   // 至此，r2一定不为NULL
        while(r2 != NULL && r2->tailvex != k) {
            pre2 = r2;
            r2 = r2->hlink;
        }

        // 至此，r2一定指向了待删除的弧
        if(pre2 == NULL) {
            G->xlist[pre->headvex].firstin = r2->hlink;
        } else {
            pre2->hlink = r2->hlink;
        }

        free(pre);

        (*G).arcnum--;
    }

    G->xlist[k].firstout = NULL;

    // 遍历其它所有链表，删除那些指向顶点v的弧；而且，下标超过k的顶点，其下标值需要递减
    for(i = 0; i < G->vexnum; i++) {
        pre = NULL;
        r = G->xlist[i].firstout;
        while(r != NULL && r->headvex < k) {
            if(r->tailvex > k) {
                r->tailvex -= 1;
            }
            pre = r;
            r = r->tlink;
        }

        // 链表上所有顶点的下标均小于k
        if(r == NULL) {
            continue;
        }

        if(r->headvex == k) {
            // 从开头删掉结点v
            if(pre == NULL) {
                G->xlist[i].firstout = r->tlink;

                // 从中间某个位置删掉结点v
            } else {
                pre->tlink = r->tlink;
            }

            // 在纵向链表上查找r的位置
            pre2 = NULL;
            r2 = G->xlist[k].firstin;   // 至此，r2一定不为NULL
            while(r2 != NULL && r2->tailvex != r->tailvex) {
                pre2 = r2;
                r2 = r2->hlink;
            }

            // 至此，r2一定指向了待删除的弧
            if(pre2 == NULL) {
                G->xlist[k].firstin = r2->hlink;
            } else {
                pre2->hlink = r2->hlink;
            }

            free(r);

            // 如果这是有向的图/网，依然需要递减边/弧的数量
            if((*G).kind == DG || (*G).kind == DN) {
                (*G).arcnum--;
            }
        }

        // 再次确定r的位置
        if(pre == NULL) {
            r = G->xlist[i].firstout;
        } else {
            r = pre->tlink;
        }

        // 下标超过k的顶点，需要递减其下标
        while(r != NULL) {
            if(r->tailvex > k) {
                r->tailvex -= 1;
            }

            if(r->headvex > k) {
                r->headvex -= 1;
            }

            r = r->tlink;
        }
    }

    // 顶点集前移
    for(i = k + 1; i < (*G).vexnum; i++) {
        G->xlist[i - 1] = G->xlist[i];
    }

    // 顶点数递减
    (*G).vexnum--;

    return OK;
}

/*
 * 构造一个边/弧结点(仅限内部使用)
 */
static ArcBox* newArcBoxPtr(int tailvex, int headvex, ArcBox* hlink, ArcBox* tlink, InfoType* info) {
    ArcBox* p = (ArcBox*) malloc(sizeof(ArcBox));
    if(!p) {
        exit(OVERFLOW);
    }

    p->tailvex = tailvex;
    p->headvex = headvex;

    p->hlink = hlink;
    p->tlink = tlink;

    p->info = info;

    return p;
}

/*
 * 插入边/弧<v, w>
 *
 * 如果当前图/网是无向的，则插入一条弧需要增加两个顶点关系，但弧的数量只增一。
 * 对于图/网来说，可以在可变参数中列出边/弧的附加信息。
 *
 * 注：此处接收的参数与MGraph有些不一样：网的附加信息中包含了各条边/弧的权值。
 */
Status InsertArc(OLGraph* G, VertexType v, VertexType w, ...) {
    int tail, head, k, count;
    ArcBox* p;
    ArcBox* pre;
    ArcBox* r;
    Boolean overlay = FALSE;   // 是否为覆盖添加
    InfoType* info = NULL;     // 边/弧的附加信息
    va_list ap;

    tail = LocateVex(*G, v); // 获取顶点v在顶点集中的位置
    if(tail == -1) {
        return ERROR;  // 指定的顶点不存在
    }

    head = LocateVex(*G, w); // 获取顶点w在顶点集中的位置
    if(head == -1) {
        return ERROR;  // 指定的顶点不存在
    }

    // 拒绝环
    if(tail == head) {
        return ERROR;
    }

    // 如果边/弧上存在附加信息
    if(IncInfo) {
        va_start(ap, w);                // 在w后查询首个可变参数
        info = va_arg(ap, InfoType*);   // 获取附加信息
        va_end(ap);
    }

    /* 接下来，需要查找合适的插入位置 */

    for(count = 0; count < 2; count++) {

        // 在横向链表上查找合适的插入位置
        pre = NULL;
        // 指向以tail为尾的首条边/弧
        r = G->xlist[tail].firstout;
        while(r != NULL && r->headvex < head) {
            pre = r;
            r = r->tlink;
        }

        // 遇到了相同位置的结点
        if(r != NULL && r->headvex == head) {
            r->info = info; // 复用该结点
            overlay = TRUE; // 发生了覆盖
        } else {
            p = newArcBoxPtr(tail, head, NULL, r, info);

            if(pre == NULL) {
                G->xlist[tail].firstout = p;
            } else {
                pre->tlink = p;
            }
        }

        // 如果没有发生覆盖，说明插入了新结点，此时需要考虑其在纵向链表上的位置
        if(overlay == FALSE) {
            // 在纵向链表上查找合适的插入位置
            pre = NULL;
            // 指向以head为头的首条边/弧
            r = G->xlist[head].firstin;
            while(r != NULL && r->tailvex < tail) {
                pre = r;
                r = r->hlink;
            }

            // 遇到了相同位置的结点
            if(r != NULL && r->tailvex == tail) {
                // 不会执行到这里，因为如果发生了覆盖，前面进不来
            } else {
                /* 至此，结点p已经存在了 */

                if(pre == NULL) {
                    p->hlink = G->xlist[head].firstin;
                    G->xlist[head].firstin = p;
                } else {
                    p->hlink = pre->hlink;
                    pre->hlink = p;
                }
            }
        }

        // 如果当前图/网是无向的，需要考虑对称性
        if((G->kind == UDG || G->kind == UDN) && tail != head) {
            // 颠倒i和j
            k = tail;
            tail = head;
            head = k;
        } else {
            break;  // 如果是有向的，可以结束了
        }
    }

    // 在非覆盖的情形下，才考虑更新边/弧的数量
    if(!overlay) {
        (*G).arcnum++;  // 不论有向无向，边/弧数只增一
    }

    return OK;
}

/*
 * 删除边/弧<v, w>
 */
Status DeleteArc(OLGraph* G, VertexType v, VertexType w) {
    int tail, head, k, count;
    ArcBox* pre, * r;
    ArcBox* pre2, * r2;

    tail = LocateVex(*G, v);
    if(tail == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    head = LocateVex(*G, w);
    if(head == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    for(count = 0; count < 2; count++) {
        pre = NULL;
        // 在横向链表中找到待删除的边/弧
        r = G->xlist[tail].firstout;
        while(r != NULL && r->headvex < head) {
            pre = r;
            r = r->tlink;
        }

        // 找到了待删除的边/弧
        if(r != NULL && r->headvex == head) {
            if(pre == NULL) {
                G->xlist[tail].firstout = r->tlink;
            } else {
                pre->tlink = r->tlink;
            }

            // 在纵向链表上查找r的位置
            pre2 = NULL;
            r2 = G->xlist[head].firstin;   // 至此，r2一定不为NULL
            while(r2 != NULL && r2->tailvex != r->tailvex) {
                pre2 = r2;
                r2 = r2->hlink;
            }

            // 至此，r2一定指向了待删除的弧
            if(pre2 == NULL) {
                G->xlist[head].firstin = r2->hlink;
            } else {
                pre2->hlink = r2->hlink;
            }

            free(r);
        } else {
            return ERROR; // 没找到
        }

        // 如果当前图/网是无向的，需要考虑对称性
        if((G->kind == UDG || G->kind == UDN) && tail != head) {
            // 颠倒tail和head
            k = tail;
            tail = head;
            head = k;
        } else {
            break;  // 如果是有向的，可以结束了
        }
    }

    (*G).arcnum--;  // 不论有向无向，边/弧数只减一

    return OK;
}

/*
 * 深度优先遍历(此处借助递归实现)
 */
void DFSTraverse(OLGraph G, Status(Visit)(VertexType)) {
    int v;

    // 使用全局变量VisitFunc，使得DFS不必设置函数指针参数
    VisitFunc = Visit;

    // 访问标志数组初始化
    for(v = 0; v < G.vexnum; v++) {
        visited[v] = FALSE;
    }

    // 此处需要遍历的原因是并不能保证所有顶点都连接在了一起
    for(v = 0; v < G.vexnum; v++) {
        if(!visited[v]) {
            DFS(G, v);  // 对尚未访问的顶点调用DFS
        }
    }
}

/*
 * 深度优先遍历核心函数
 */
static void DFS(OLGraph G, int v) {
    int w;

    // 从第v个顶点出发递归地深度优先遍历图G
    visited[v] = TRUE;

    // 访问第v个顶点
    VisitFunc(G.xlist[v].data);

    for(w = FirstAdjVex(G, G.xlist[v].data);
        w >= 0;
        w = NextAdjVex(G, G.xlist[v].data, G.xlist[w].data)) {
        if(!visited[w]) {
            DFS(G, w);  // 对尚未访问的顶点调用DFS
        }
    }
}

/*
 * 广度优先遍历(此处借助队列实现)
 */
void BFSTraverse(OLGraph G, Status(Visit)(VertexType)) {
    int v, w;
    LinkQueue Q;
    QElemType u;

    // 初始化为未访问
    for(v = 0; v < G.vexnum; v++) {
        visited[v] = FALSE;
    }

    // 置空辅助队列
    InitQueue(&Q);

    for(v = 0; v < G.vexnum; v++) {
        // 如果该顶点已访问过，则直接忽略
        if(visited[v]) {
            continue;
        }

        // 标记该顶点已访问
        visited[v] = TRUE;

        // 访问顶点
        Visit(G.xlist[v].data);

        EnQueue(&Q, v);

        while(!QueueEmpty(Q)) {
            DeQueue(&Q, &u);

            // 先集中访问顶点v的邻接顶点，随后再访问邻接顶点的邻接顶点
            for(w = FirstAdjVex(G, G.xlist[u].data);
                w >= 0;
                w = NextAdjVex(G, G.xlist[u].data, G.xlist[w].data)) {
                if(!visited[w]) {
                    visited[w] = TRUE;
                    Visit(G.xlist[w].data);
                    EnQueue(&Q, w);
                }
            }
        }
    }
}

/*
 * 以图形化形式输出当前结构
 */
void PrintGraph(OLGraph G) {
    int i, head;
    ArcBox* p;

    if(G.vexnum == 0) {
        printf("空图，无需打印！\n");
        return;
    }

    printf("当前图/网包含 %2d 个顶点， %2d 条边/弧...\n", G.vexnum, G.arcnum);

    for(i = 0; i < G.vexnum; i++) {
        printf("%c ===> ", G.xlist[i].data);

        head = 0;
        p = G.xlist[i].firstout;

        while(p != NULL) {
            if(head < p->headvex) {
                if(IncInfo == 0) {
                    printf("      ");

                    // 对于网，会从其附加信息中获取到权值
                } else {
                    printf("          ");
                }
            } else {
                if(IncInfo == 0) {
                    printf("<%c, %c>", G.xlist[p->tailvex].data, G.xlist[p->headvex].data);

                    // 对于网，会从其附加信息中获取到权值
                } else {
                    printf("<%c, %c, %2d>", G.xlist[p->tailvex].data, G.xlist[p->headvex].data, p->info->weight);
                }

                p = p->tlink;
            }

            head++;

            if(p != NULL) {
                printf("  ");
            }
        }

        printf("\n");
    }
}

// 图的类型
// 图的类型
typedef enum {
    DG,     // 0-有向图；此处不支持
    DN,     // 1-有向网(带权值)；此处不支持
    UDG,    // 2-无向图
    UDN     // 3-无向网(带权值)
} GraphKind;


/* 无向图（邻接多重表）类型定义 */
typedef enum {
    unvisit, visit
} VisitIf;

// 顶点类型
typedef char VertexType;

// 边的相关附加信息
typedef struct {
    /*
     * 注：
     * 教材中给出的结构只考虑了无权图，而没考虑有权图(网)。
     * 这里为了把“网”的情形也考虑进去，特在附加信息中增加了"权重"属性。
     */
    int weight;
} InfoType;

/* 边结点 */
typedef struct EBox {
    VisitIf mark;       // 访问标记
    int ivex;           // 该边依附的两个顶点的位置
    int jvex;           // 该边依附的两个顶点的位置
    struct EBox* ilink; // 分别指向依附这两个顶点的下一条边
    struct EBox* jlink; // 分别指向依附这两个顶点的下一条边
    InfoType* info;
} EBox;

// 每个链表的头结点
typedef struct VexBox {
    VertexType data;    // 顶点信息
    EBox* firstedge;    // 指向第一条依附该顶点的边的指针
} VexBox;

/* 图的邻接多重表存储表示类型定义 */
typedef struct {
    VexBox adjmulist[MAX_VERTEX_NUM];   // 表头向量
    int vexnum, edgenum;                // 图/网的顶点数和边数
    GraphKind kind;                     // 图的类型标志
} AMLGraph;


// 边/弧上是否存在附加信息
extern Boolean IncInfo;

// 录入数据的源文件；fp为null时，说明需要从控制台录入
static FILE* fp = NULL;

/*
 * IncInfo指示该图的边上是否存在附加信息。
 * 如果其值不为0，则表示无附加信息，否则，表示存在附加信息。
 */
Boolean IncInfo = FALSE;

// 访问标志数组，记录访问过的顶点
static Boolean visited[MAX_VERTEX_NUM];

// 函数变量
static Status (* VisitFunc)(VertexType e);


/*
 * 创建
 *
 *【备注】
 *
 * 教材中默认从控制台读取数据。
 * 这里为了方便测试，避免每次运行都手动输入数据，
 * 因而允许选择从预设的文件path中读取测试数据。
 *
 * 如果需要从控制台读取数据，则path为NULL，或path[kind]为""。
 * 如果需要从文件中读取数据，则需要在path中填写文件名信息。
 */
Status CreateGraph(AMLGraph* G, char* path[]) {
    int readFromConsole;    // 是否从控制台读取数据
    int kind;
    Status flag;

    printf("请输入图的类型(2-无向图 │ 3-无向网)：");
    scanf("%d", &kind);

    // 类型不合规(只接受无向的图/网)
    if(kind < 2 || kind > 3) {
        return ERROR;
    }

    // 如果没有文件路径信息，则从控制台读取输入
    readFromConsole = (path == NULL) || strcmp(path[kind], "") == 0;

    // 需要从文件读取
    if(readFromConsole) {
        (*G).kind = kind;   // 记录图/网的类型
    } else {
        // 打开文件，准备读取测试数据
        fp = fopen(path[kind], "r");
        if(fp == NULL) {
            return ERROR;
        }

        // 录入图的类型
        ReadData(fp, "%d", &((*G).kind));
    }

    // 随机创建无向图或无向网的一种
    switch((*G).kind) {
        case UDG:
            flag = CreateUDG(G);
            break;
        case UDN:
            flag = CreateUDN(G);
            break;
        default:
            flag = ERROR;
            break;
    }

    if(fp != NULL) {
        fclose(fp);
        fp = NULL;
    }

    return flag;
}

/*
 * 构造无向图
 */
static Status CreateUDG(AMLGraph* G) {
    int i, k;
    int vexnum, arcnum;
    VertexType v1, v2;
    InfoType* info = NULL;

    (*G).vexnum = (*G).edgenum = 0;

    if(fp == NULL) {
        printf("请输入无向图的顶点数：");
        scanf("%d", &vexnum);
        printf("请输入无向图的边数：");
        scanf("%d", &arcnum);
        printf("该无向图的边上是否包含其他附加信息(0-不包含│1-包含)：");
        scanf("%d", &IncInfo);

        // 录入顶点集
        printf("请录入 %d 个顶点，不同顶点之间用空格隔开：", vexnum);
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(stdin);
            scanf("%c", &((*G).adjmulist[i].data));
            (*G).adjmulist[i].firstedge = NULL;
            (*G).vexnum++;
        }
    } else {
        ReadData(fp, "%d", &vexnum); // 录入顶点数
        ReadData(fp, "%d", &arcnum); // 录入边数
        ReadData(fp, "%d", &IncInfo);// 判断边上是否包含附加信息

        // 录入顶点集
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(fp);
            ReadData(fp, "%c", &((*G).adjmulist[i].data));
            (*G).adjmulist[i].firstedge = NULL;
            (*G).vexnum++;
        }
    }

    // 仅在控制台录入信息时输出此提示
    if(fp == NULL && arcnum != 0) {
        printf("请为无向图依次录入 %d 条边的信息，顶点之间用空格隔开：\n", arcnum);
    }

    // 录入边的信息
    for(k = 0; k < arcnum; k++) {
        if(fp == NULL) {
            printf("第 %2d 条边：", k + 1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v2);
        } else {
            // 跳过空白，寻找下一个可读符号
            skipBlank(fp);
            ReadData(fp, "%c%c", &v1, &v2);
        }

        // 如果需要录入边的其他附加信息
        if(IncInfo) {
            // 最后录入附加信息
            Input(*G, &info);
        }

        // 插入边<v1, v2>
        InsertArc(G, v1, v2, info);
    }

    // 从文件中读取数据时，最后其实应当判断一下是否读到了足够的信息
    return OK;
}

/*
 * 构造无向网
 */
static Status CreateUDN(AMLGraph* G) {
    int i, k;
    int vexnum, arcnum;
    VertexType v1, v2;
    InfoType* info = NULL;

    (*G).vexnum = (*G).edgenum = 0;

    if(fp == NULL) {
        printf("请输入无向网的顶点数：");
        scanf("%d", &vexnum);
        printf("请输入无向网的边数：");
        scanf("%d", &arcnum);
        printf("该无向网的边上必须包含其他附加信息，因为此处的权值需要存储到附加信息中...\n");
        IncInfo = 1;

        // 录入顶点集
        printf("请录入 %d 个顶点，不同顶点之间用空格隔开：", vexnum);
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(stdin);
            scanf("%c", &((*G).adjmulist[i].data));
            (*G).adjmulist[i].firstedge = NULL;
            (*G).vexnum++;
        }
    } else {
        ReadData(fp, "%d", &vexnum); // 录入顶点数
        ReadData(fp, "%d", &arcnum); // 录入边数
        ReadData(fp, "%d", &IncInfo);// 判断边上是否包含附加信息
        IncInfo = 1;    // 强制将权值录入到附加信息中

        // 录入顶点集
        for(i = 0; i < vexnum; i++) {
            // 跳过空白，寻找下一个"可读"符号
            skipBlank(fp);
            ReadData(fp, "%c", &((*G).adjmulist[i].data));
            (*G).adjmulist[i].firstedge = NULL;
            (*G).vexnum++;
        }
    }

    // 仅在控制台录入信息时输出此提示
    if(fp == NULL && arcnum != 0) {
        printf("请为无向网依次录入 %d 条边(带权值)的信息，顶点及权值之间用空格隔开：\n", arcnum);
    }

    // 录入边的信息
    for(k = 0; k < arcnum; k++) {
        if(fp == NULL) {
            printf("第 %2d 条边及其权值：", k + 1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v1);
            skipBlank(stdin);   // 跳过空白，寻找下一个可读符号
            scanf("%c", &v2);
        } else {
            // 跳过空白，寻找下一个可读符号
            skipBlank(fp);
            ReadData(fp, "%c%c", &v1, &v2);
        }

        // 如果需要录入边的其他附加信息
        if(IncInfo) {
            // 最后录入附加信息(此处需要录入网的权值)
            Input(*G, &info);
        }

        // 插入边<v1, v2>
        InsertArc(G, v1, v2, info);
    }

    // 从文件中读取数据时，最后其实应当判断一下是否读到了足够的信息
    return OK;
}

/*
 * 录入边的相关附加信息
 */
static void Input(AMLGraph G, InfoType** info) {
    int weight;

    // 在"网"的情形下需要录入权值信息
    if(G.kind == UDN) {
        *info = (InfoType*) malloc(sizeof(InfoType));

        if(fp == NULL) {
            scanf("%d", &weight);
        } else {
            ReadData(fp, "%d", &weight);
        }

        (*info)->weight = weight;
    }
}

/*
 * 销毁
 *
 * 邻接表存储的图需要释放内存。
 */
Status DestroyGraph(AMLGraph* G) {
    int k, other;
    EBox* p, * r;

    // 逆序遍历
    for(k = G->vexnum-1; k >=0; k--) {
        p = NULL;
        r = G->adjmulist[k].firstedge;

        // 删除ivex处为k的边，保留jvex处为k的边
        while(r != NULL) {
            if(r->ivex == k) {
                other = r->jvex;
            } else if(r->jvex==k) {
                other = r->ivex;
            } else {
                // 不会至此
            }

            // 暂时保存这条边
            if(other<k) {
                p = r;

                if(r->ivex == k) {
                    r = r->ilink;
                } else if(r->jvex==k) {
                    r = r->jlink;
                } else {
                    // 不会至此
                }

                // 删除这条边
            } else {
                if(p==NULL) {
                    if(r->ivex == k) {
                        G->adjmulist[k].firstedge = r->ilink;
                    } else if(r->jvex==k) {
                        G->adjmulist[k].firstedge = r->jlink;
                    } else {
                        // 不会至此
                    }

                    free(r);
                    r = G->adjmulist[k].firstedge;
                } else {
                    if(p->ivex==k) {
                        if(r->ivex == k) {
                            p->ilink = r->ilink;
                        } else if(r->jvex==k) {
                            p->ilink = r->jlink;
                        } else {
                            // 不会至此
                        }

                        free(r);
                        r = p->ilink;
                    } else if(p->jvex==k) {
                        if(r->ivex == k) {
                            p->jlink = r->ilink;
                        } else if(r->jvex==k) {
                            p->jlink = r->jlink;
                        } else {
                            // 不会至此
                        }

                        free(r);
                        r = p->jlink;
                    } else {
                        // 不会至此
                    }
                }
            }
        }
    }

    (*G).vexnum = 0;
    (*G).edgenum = 0;
    IncInfo = 0;

    return OK;
}

/*
 * 查找
 *
 * 返回顶点u在图/网中的位置
 */
int LocateVex(AMLGraph G, VertexType u) {
    int i;

    for(i = 0; i < G.vexnum; i++) {
        if(G.adjmulist[i].data == u) {
            return i;
        }
    }

    return -1;
}

/*
 * 取值
 *
 * 返回索引v处的顶点值
 */
VertexType GetVex(AMLGraph G, int v) {
    if(v < 0 || v >= G.vexnum) {
        return '\0';    // 指定的顶点不存在
    }

    return G.adjmulist[v].data;
}

/*
 * 赋值
 *
 * 将顶点v赋值为value
 */
Status PutVex(AMLGraph* G, VertexType v, VertexType value) {
    int k;

    // 首先需要判断该顶点是否存在
    k = LocateVex((*G), v);
    if(k == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    // 替换头结点
    (*G).adjmulist[k].data = value;

    /* 链表中的元素存储的是顶点的位置，所以无需遍历链表来替换目标值 */

    return OK;
}

/*
 * 首个邻接点
 *
 * 返回顶点v的首个邻接点
 */
int FirstAdjVex(AMLGraph G, VertexType v) {
    int k;
    EBox* r;

    // 首先需要判断该顶点是否存在
    k = LocateVex(G, v);
    if(k == -1) {
        return -1;    // 指定的顶点不存在
    }

    r = G.adjmulist[k].firstedge;
    if(r == NULL) {
        return -1;
    } else {
        if(r->ivex == k) {
            return r->jvex;
        } else if(r->jvex==k) {
            return r->ivex;
        } else {
            return -1;  // 不会至此
        }
    }
}

/*
 * 下一个邻接点
 *
 * 返回顶点v的(相对于w的)下一个邻接点
 */
int NextAdjVex(AMLGraph G, VertexType v, VertexType w) {
    int kv, kw;
    EBox* r;

    // 首先需要判断该顶点是否存在
    kv = LocateVex(G, v);
    if(kv == -1) {
        return -1;    // 指定的顶点不存在
    }

    // 首先需要判断该顶点是否存在
    kw = LocateVex(G, w);
    if(kw == -1) {
        return -1;    // 指定的顶点不存在
    }

    r = G.adjmulist[kv].firstedge;
    if(r == NULL) {
        return -1;    // 链表为空
    }

    // 在链表中查找w
    while(r != NULL) {
        if(r->ivex == kv && r->jvex < kw) {
            r = r->ilink;
        } else if(r->jvex == kv && r->ivex < kw) {
            r = r->jlink;
        } else {
            break;
        }
    }

    // 如果没找到w
    if(r == NULL) {
        return -1;
    }

    // 如果找到了w，但是w后面没有别的顶点，那么也无法返回邻接点
    if(r->ivex == kv && r->jvex == kw && r->ilink!=NULL) {
        r = r->ilink;
    } else if(r->jvex == kv && r->ivex == kw && r->jlink!=NULL) {
        r = r->jlink;
    } else {
        return -1;
    }

    // 向相邻的边中获取到相邻顶点
    if(r->ivex==kv) {
        return r->jvex;
    } else if(r->jvex==kv) {
        return r->ivex;
    } else {
        return -1;  // 不会至此
    }
}

/*
 * 插入顶点
 *
 * 将指定的顶点v追加到顶点集中，未建立该顶点与其他顶点的关系
 */
Status InsertVex(AMLGraph* G, VertexType v) {
    int k;

    // 顶点数过多
    if((*G).vexnum == MAX_VERTEX_NUM) {
        return ERROR;
    }

    // 首先需要判断该顶点是否存在
    k = LocateVex(*G, v);
    if(k >= 0) {
        return ERROR;    // 指定的顶点存在时，无需重复添加
    }

    G->adjmulist[(*G).vexnum].data = v;
    G->adjmulist[(*G).vexnum].firstedge = NULL;

    (*G).vexnum++;

    return OK;
}

/*
 * 删除顶点
 *
 * 从顶点集中删除指定的顶点v，注意需要更新相关的顶点关系
 */
Status DeleteVex(AMLGraph* G, VertexType v) {
    int i, k, other;
    EBox* p;
    EBox* pre, * r;

    // 首先需要判断该顶点是否存在
    k = LocateVex(*G, v);
    if(k == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    while((p = G->adjmulist[k].firstedge) != NULL) {
        if(p->ivex == k) {
            G->adjmulist[k].firstedge = p->ilink;
            other = p->jvex;
        } else if(p->jvex == k) {
            G->adjmulist[k].firstedge = p->jlink;
            other = p->ivex;
        } else {
            // 没有其他可能
        }

        pre = NULL;
        r = G->adjmulist[other].firstedge;

        // 查找边<other, k>，肯定能找到
        while(r != NULL) {
            if(r->ivex == other && r->jvex < k) {
                pre = r;
                r = r->ilink;
            } else if(r->jvex == other && r->ivex < k) {
                pre = r;
                r = r->jlink;
            } else {
                break;
            }
        }

        if(r != NULL && r->ivex == other && r->jvex == k) {
            if(pre == NULL) {
                G->adjmulist[other].firstedge = r->ilink;
            } else {
                if(pre->ivex == other) {
                    pre->ilink = r->ilink;
                } else if(pre->jvex == other) {
                    pre->jlink = r->ilink;
                } else {
                    // 没有其他可能
                }
            }
        } else if(r != NULL && r->jvex == other && r->ivex == k) {
            if(pre == NULL) {
                G->adjmulist[other].firstedge = r->jlink;
            } else {
                if(pre->ivex == other) {
                    pre->ilink = r->jlink;
                } else if(pre->jvex == other) {
                    pre->jlink = r->jlink;
                } else {
                    // 没有其他可能
                }
            }
        } else {
            // 不会至此，因为肯定能找到
        }

        free(p);

        (*G).edgenum--;  // 边数减一
    }

    // 下标超过k的顶点，需要递减其下标
    for(i = k + 1; i < (*G).vexnum; i++) {
        r = G->adjmulist[i].firstedge;

        while(r!=NULL){
            if(r->ivex==i) {
                r->ivex--;
                r = r->ilink;
            } else if(r->jvex==i) {
                r->jvex--;
                r = r->jlink;
            } else {
                // 不会至此
            }
        }
    }

    // 顶点集前移
    for(i = k + 1; i < (*G).vexnum; i++) {
        G->adjmulist[i - 1] = G->adjmulist[i];
    }

    // 顶点数递减
    (*G).vexnum--;

    return OK;
}

/*
 * 构造一个边结点(仅限内部使用)
 */
static EBox* newEBoxPtr(VisitIf mark, int ivex, int jvex, EBox* ilink, EBox* jlink, InfoType* info) {
    EBox* p = (EBox*) malloc(sizeof(EBox));
    if(!p) {
        exit(OVERFLOW);
    }

    p->mark = mark;

    p->ivex = ivex;
    p->jvex = jvex;

    p->ilink = ilink;
    p->jlink = jlink;

    p->info = info;

    return p;
}

/*
 * 插入边<v, w>
 *
 * 当前图/网是无向的，且由于特殊的结构，使得插入一条边时只需要增加一对顶点关系，边的数量依然增一。
 * 对于图/网来说，可以在可变参数中列出边的附加信息。
 *
 * 注：此处接收的参数与MGraph有些不一样：网的附加信息中包含了各条边的权值。
 */
Status InsertArc(AMLGraph* G, VertexType v, VertexType w, ...) {
    int tail, head, k;
    EBox* p;
    EBox* pre;
    EBox* r;
    Boolean overlay = FALSE;   // 是否为覆盖添加
    InfoType* info = NULL;     // 边的附加信息
    va_list ap;

    tail = LocateVex(*G, v); // 获取顶点v在顶点集中的位置
    if(tail == -1) {
        return ERROR;  // 指定的顶点不存在
    }

    head = LocateVex(*G, w); // 获取顶点w在顶点集中的位置
    if(head == -1) {
        return ERROR;  // 指定的顶点不存在
    }

    // 拒绝环
    if(tail == head) {
        return ERROR;
    }

    // 如果边上存在附加信息
    if(IncInfo) {
        va_start(ap, w);                // 在w后查询首个可变参数
        info = va_arg(ap, InfoType*);   // 获取附加信息
        va_end(ap);
    }

    /* 接下来，需要查找合适的插入位置 */

    pre = NULL;
    r = G->adjmulist[tail].firstedge;

    while(r != NULL) {
        if(r->ivex == tail && r->jvex < head) {
            pre = r;
            r = r->ilink;
        } else if(r->jvex == tail && r->ivex < head) {
            pre = r;
            r = r->jlink;
        } else {
            break;
        }
    }

    if(r != NULL && r->ivex == tail && r->jvex == head) {
        r->info = info; // 复用该结点
        overlay = TRUE; // 发生了覆盖
    } else if(r != NULL && r->jvex == tail && r->ivex == head) {
        r->info = info; // 复用该结点
        overlay = TRUE; // 发生了覆盖
    } else {
        p = newEBoxPtr(unvisit, tail, head, r, NULL, info);

        if(pre == NULL) {
            G->adjmulist[tail].firstedge = p;
        } else {
            if(pre->ivex == tail) {
                pre->ilink = p;
            } else if(pre->jvex == tail) {
                pre->jlink = p;
            } else {
                // 没有其他可能
            }
        }
    }

    if(!overlay) {
        pre = NULL;
        r = G->adjmulist[head].firstedge;

        while(r != NULL) {
            if(r->ivex == head && r->jvex < tail) {
                pre = r;
                r = r->ilink;
            } else if(r->jvex == head && r->ivex < tail) {
                pre = r;
                r = r->jlink;
            } else {
                break;
            }
        }

        p->jlink = r;

        if(pre == NULL) {
            G->adjmulist[head].firstedge = p;
        } else {
            if(pre->ivex == head) {
                pre->ilink = p;
            } else if(pre->jvex == head) {
                pre->jlink = p;
            } else {
                // 没有其他可能
            }
        }
    }

    (*G).edgenum++;  // 边数增一

    return OK;
}

/*
 * 删除边<v, w>
 */
Status DeleteArc(AMLGraph* G, VertexType v, VertexType w) {
    int tail, head;
    EBox* r;
    EBox* pre;

    tail = LocateVex(*G, v);
    if(tail == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    head = LocateVex(*G, w);
    if(head == -1) {
        return ERROR;    // 指定的顶点不存在
    }

    pre = NULL;
    r = G->adjmulist[tail].firstedge;

    while(r != NULL) {
        if(r->ivex == tail && r->jvex < head) {
            pre = r;
            r = r->ilink;
        } else if(r->jvex == tail && r->ivex < head) {
            pre = r;
            r = r->jlink;
        } else {
            break;
        }
    }

    if(r != NULL && r->ivex == tail && r->jvex == head) {
        if(pre == NULL) {
            G->adjmulist[tail].firstedge = r->ilink;
        } else {
            if(pre->ivex == tail) {
                pre->ilink = r->ilink;
            } else if(pre->jvex == tail) {
                pre->jlink = r->ilink;
            } else {
                // 没有其他可能
            }
        }
    } else if(r != NULL && r->jvex == tail && r->ivex == head) {
        if(pre == NULL) {
            G->adjmulist[tail].firstedge = r->jlink;
        } else {
            if(pre->ivex == tail) {
                pre->ilink = r->jlink;
            } else if(pre->jvex == tail) {
                pre->jlink = r->jlink;
            } else {
                // 没有其他可能
            }
        }
    } else {
        return ERROR;   // 未找到
    }


    pre = NULL;
    r = G->adjmulist[head].firstedge;

    while(r != NULL) {
        if(r->ivex == head && r->jvex < tail) {
            pre = r;
            r = r->ilink;
        } else if(r->jvex == head && r->ivex < tail) {
            pre = r;
            r = r->jlink;
        } else {
            break;
        }
    }

    if(r != NULL && r->ivex == head && r->jvex == tail) {
        if(pre == NULL) {
            G->adjmulist[head].firstedge = r->ilink;
        } else {
            if(pre->ivex == head) {
                pre->ilink = r->ilink;
            } else if(pre->jvex == head) {
                pre->jlink = r->ilink;
            } else {
                // 没有其他可能
            }
        }
    } else if(r != NULL && r->jvex == head && r->ivex == tail) {
        if(pre == NULL) {
            G->adjmulist[head].firstedge = r->jlink;
        } else {
            if(pre->ivex == head) {
                pre->ilink = r->jlink;
            } else if(pre->jvex == head) {
                pre->jlink = r->jlink;
            } else {
                // 没有其他可能
            }
        }
    } else {
        // 不会至此，因为前面找到了，此处肯定也能找到
    }

    free(r); // 释放内存

    (*G).edgenum--;  // 边数减一

    return OK;
}

/*
 * 深度优先遍历(此处借助递归实现)
 */
void DFSTraverse(AMLGraph G, Status(Visit)(VertexType)) {
    int v;

    // 使用全局变量VisitFunc，使得DFS不必设置函数指针参数
    VisitFunc = Visit;

    // 访问标志数组初始化
    for(v = 0; v < G.vexnum; v++) {
        visited[v] = FALSE;
    }

    // 此处需要遍历的原因是并不能保证所有顶点都连接在了一起
    for(v = 0; v < G.vexnum; v++) {
        if(!visited[v]) {
            DFS(G, v);  // 对尚未访问的顶点调用DFS
        }
    }
}

/*
 * 深度优先遍历核心函数
 */
static void DFS(AMLGraph G, int v) {
    int w;

    // 从第v个顶点出发递归地深度优先遍历图G
    visited[v] = TRUE;

    // 访问第v个顶点
    VisitFunc(G.adjmulist[v].data);

    for(w = FirstAdjVex(G, G.adjmulist[v].data);
        w >= 0;
        w = NextAdjVex(G, G.adjmulist[v].data, G.adjmulist[w].data)) {
        if(!visited[w]) {
            DFS(G, w);  // 对尚未访问的顶点调用DFS
        }
    }
}

/*
 * 广度优先遍历(此处借助队列实现)
 */
void BFSTraverse(AMLGraph G, Status(Visit)(VertexType)) {
    int v, w;
    LinkQueue Q;
    QElemType u;

    // 初始化为未访问
    for(v = 0; v < G.vexnum; v++) {
        visited[v] = FALSE;
    }

    // 置空辅助队列
    InitQueue(&Q);

    for(v = 0; v < G.vexnum; v++) {
        // 如果该顶点已访问过，则直接忽略
        if(visited[v]) {
            continue;
        }

        // 标记该顶点已访问
        visited[v] = TRUE;

        // 访问顶点
        Visit(G.adjmulist[v].data);

        EnQueue(&Q, v);

        while(!QueueEmpty(Q)) {
            DeQueue(&Q, &u);

            // 先集中访问顶点v的邻接顶点，随后再访问邻接顶点的邻接顶点
            for(w = FirstAdjVex(G, G.adjmulist[u].data);
                w >= 0;
                w = NextAdjVex(G, G.adjmulist[u].data, G.adjmulist[w].data)) {
                if(!visited[w]) {
                    visited[w] = TRUE;
                    Visit(G.adjmulist[w].data);
                    EnQueue(&Q, w);
                }
            }
        }
    }
}

/*
 * 以图形化形式输出当前结构
 */
void PrintGraph(AMLGraph G) {
    int i, cur, pos;
    EBox* p;

    if(G.vexnum == 0) {
        printf("空图，无需打印！\n");
        return;
    }

    printf("当前图/网包含 %2d 个顶点， %2d 条边...\n", G.vexnum, G.edgenum);

    for(i = 0; i < G.vexnum; i++) {
        printf("%c ===> ", G.adjmulist[i].data);

        cur = 0;
        p = G.adjmulist[i].firstedge;

        while(p != NULL) {
            if(p->ivex == i) {
                pos = p->jvex;
            } else {
                pos = p->ivex;
            }

            if(cur < pos) {
                if(IncInfo == 0) {
                    printf(" ");

                    // 对于网，会从其附加信息中获取到权值
                } else {
                    printf("     ");
                }
            } else {
                if(IncInfo == 0) {
                    printf("%c", G.adjmulist[pos].data);

                    // 对于网，会从其附加信息中获取到权值
                } else {
                    printf("%c[%2d]", G.adjmulist[pos].data, p->info->weight);
                }

                if(p->ivex == i) {
                    p = p->ilink;
                } else {
                    p = p->jlink;
                }
            }

            cur++;

            if(p != NULL) {
                printf("  ");
            }
        }

        printf("\n");
    }
}
  • 图的深度遍历、广度遍历（基于邻接矩阵、邻接表）__*

邻接矩阵

/*
 * ████████ 算法7.4 ████████
 *
 * 深度优先遍历(此处借助递归实现)
 */
void DFSTraverse(MGraph G, Status(Visit)(VertexType)) {
    int v;

    // 使用全局变量VisitFunc，使得DFS不必设置函数指针参数
    VisitFunc = Visit;

    // 访问标志数组初始化
    for(v = 0; v < G.vexnum; v++) {
        visited[v] = FALSE;
    }

    // 此处需要遍历的原因是并不能保证所有顶点都连接在了一起
    for(v = 0; v < G.vexnum; v++) {
        if(!visited[v]) {
            DFS(G, v);  // 对尚未访问的顶点调用DFS
        }
    }
}

/*
 * ████████ 算法7.5 ████████
 *
 * 深度优先遍历核心函数
 */
static void DFS(MGraph G, int v) {
    int w;

    // 从第v个顶点出发递归地深度优先遍历图G
    visited[v] = TRUE;

    // 访问第v个顶点
    VisitFunc(G.vexs[v]);

    for(w = FirstAdjVex(G, G.vexs[v]);
        w >= 0;
        w = NextAdjVex(G, G.vexs[v], G.vexs[w])) {
        if(!visited[w]) {
            DFS(G, w);  // 对尚未访问的顶点调用DFS
        }
    }
}

/*
 * ████████ 算法7.6 ████████
 *
 * 广度优先遍历(此处借助队列实现)
 */
void BFSTraverse(MGraph G, Status(Visit)(VertexType)) {
    int v, w;
    LinkQueue Q;
    QElemType u;

    // 初始化为未访问
    for(v = 0; v < G.vexnum; v++) {
        visited[v] = FALSE;
    }

    // 置空辅助队列
    InitQueue(&Q);

    for(v = 0; v < G.vexnum; v++) {
        // 如果该顶点已访问过，则直接忽略
        if(visited[v]) {
            continue;
        }

        // 标记该顶点已访问
        visited[v] = TRUE;

        // 访问顶点
        Visit(G.vexs[v]);

        EnQueue(&Q, v);

        while(!QueueEmpty(Q)) {
            DeQueue(&Q, &u);

            // 先集中访问顶点v的邻接顶点，随后再访问邻接顶点的邻接顶点
            for(w = FirstAdjVex(G, G.vexs[u]);
                w >= 0;
                w = NextAdjVex(G, G.vexs[u], G.vexs[w])) {
                if(!visited[w]) {
                    visited[w] = TRUE;
                    Visit(G.vexs[w]);
                    EnQueue(&Q, w);
                }
            }
        }
    }
}

邻接表

/*
 * 深度优先遍历(此处借助递归实现)
 */
void DFSTraverse(ALGraph G, Status(Visit)(VertexType)) {
    int v;

    // 使用全局变量VisitFunc，使得DFS不必设置函数指针参数
    VisitFunc = Visit;

    // 访问标志数组初始化
    for(v = 0; v < G.vexnum; v++) {
        visited[v] = FALSE;
    }

    // 此处需要遍历的原因是并不能保证所有顶点都连接在了一起
    for(v = 0; v < G.vexnum; v++) {
        if(!visited[v]) {
            DFS(G, v);  // 对尚未访问的顶点调用DFS
        }
    }
}

/*
 * 深度优先遍历核心函数
 */
static void DFS(ALGraph G, int v) {
    int w;

    // 从第v个顶点出发递归地深度优先遍历图G
    visited[v] = TRUE;

    // 访问第v个顶点
    VisitFunc(G.vertices[v].data);

    for(w = FirstAdjVex(G, G.vertices[v].data);
        w >= 0;
        w = NextAdjVex(G, G.vertices[v].data, G.vertices[w].data)) {
        if(!visited[w]) {
            DFS(G, w);  // 对尚未访问的顶点调用DFS
        }
    }
}

/*
 * 广度优先遍历(此处借助队列实现)
 */
void BFSTraverse(ALGraph G, Status(Visit)(VertexType)) {
    int v, w;
    LinkQueue Q;
    QElemType u;

    // 初始化为未访问
    for(v = 0; v < G.vexnum; v++) {
        visited[v] = FALSE;
    }

    // 置空辅助队列
    InitQueue(&Q);

    for(v = 0; v < G.vexnum; v++) {
        // 如果该顶点已访问过，则直接忽略
        if(visited[v]) {
            continue;
        }

        // 标记该顶点已访问
        visited[v] = TRUE;

        // 访问顶点
        Visit(G.vertices[v].data);

        EnQueue(&Q, v);

        while(!QueueEmpty(Q)) {
            DeQueue(&Q, &u);

            // 先集中访问顶点v的邻接顶点，随后再访问邻接顶点的邻接顶点
            for(w = FirstAdjVex(G, G.vertices[u].data);
                w >= 0;
                w = NextAdjVex(G, G.vertices[u].data, G.vertices[w].data)) {
                if(!visited[w]) {
                    visited[w] = TRUE;
                    Visit(G.vertices[w].data);
                    EnQueue(&Q, w);
                }
            }
        }
    }
}

/*
 * 深度优先遍历(此处借助递归实现)
 */
void DFSTraverse(OLGraph G, Status(Visit)(VertexType)) {
    int v;

    // 使用全局变量VisitFunc，使得DFS不必设置函数指针参数
    VisitFunc = Visit;

    // 访问标志数组初始化
    for(v = 0; v < G.vexnum; v++) {
        visited[v] = FALSE;
    }

    // 此处需要遍历的原因是并不能保证所有顶点都连接在了一起
    for(v = 0; v < G.vexnum; v++) {
        if(!visited[v]) {
            DFS(G, v);  // 对尚未访问的顶点调用DFS
        }
    }
}

/*
 * 深度优先遍历核心函数
 */
static void DFS(OLGraph G, int v) {
    int w;

    // 从第v个顶点出发递归地深度优先遍历图G
    visited[v] = TRUE;

    // 访问第v个顶点
    VisitFunc(G.xlist[v].data);

    for(w = FirstAdjVex(G, G.xlist[v].data);
        w >= 0;
        w = NextAdjVex(G, G.xlist[v].data, G.xlist[w].data)) {
        if(!visited[w]) {
            DFS(G, w);  // 对尚未访问的顶点调用DFS
        }
    }
}

/*
 * 广度优先遍历(此处借助队列实现)
 */
void BFSTraverse(OLGraph G, Status(Visit)(VertexType)) {
    int v, w;
    LinkQueue Q;
    QElemType u;

    // 初始化为未访问
    for(v = 0; v < G.vexnum; v++) {
        visited[v] = FALSE;
    }

    // 置空辅助队列
    InitQueue(&Q);

    for(v = 0; v < G.vexnum; v++) {
        // 如果该顶点已访问过，则直接忽略
        if(visited[v]) {
            continue;
        }

        // 标记该顶点已访问
        visited[v] = TRUE;

        // 访问顶点
        Visit(G.xlist[v].data);

        EnQueue(&Q, v);

        while(!QueueEmpty(Q)) {
            DeQueue(&Q, &u);

            // 先集中访问顶点v的邻接顶点，随后再访问邻接顶点的邻接顶点
            for(w = FirstAdjVex(G, G.xlist[u].data);
                w >= 0;
                w = NextAdjVex(G, G.xlist[u].data, G.xlist[w].data)) {
                if(!visited[w]) {
                    visited[w] = TRUE;
                    Visit(G.xlist[w].data);
                    EnQueue(&Q, w);
                }
            }
        }
    }
}

拓扑排序

/*
 * ████████ 算法7.12 ████████
 *
 * 如果有向图G无回路，则输出它的一个拓扑序列并返回OK；否则，返回FALSE。
 * 拓扑序列通常不唯一，但是必须保证某些关键节点的先后次序。
 *
 * 注：与教材不同之处在于，此处增加了一个topo数组做参数。
 * 　　对于求出的拓扑序列，不会直接输出，而是会缓存到topo中。
 * 　　这样的做的目的是后续的习题中会有多处用到该拓扑序列。
 */
Status TopologicalSort(ALGraph G, int topo[MAX_VERTEX_NUM]) {
    int i, k, count;
    int indegree[MAX_VERTEX_NUM];
    SqStack S;
    ArcNode* p;

    // 对各顶点求入度
    FindInDegree(G, indegree);

    // 初始化零入度顶点栈
    InitStack(&S);

    // 建立入度为0的顶点栈
    for(i = 0; i < G.vexnum; i++) {
        // 将入度为0的顶点添加到栈中
        if(indegree[i] == 0) {
            Push(&S, i);
        }
    }

    // 对拓扑序列中的顶点计数
    count = 0;

    // 遍历顶点栈
    while(!StackEmpty(S)) {
        // 获取一个零入度顶点
        Pop(&S, &i);

        // 将各顶点的序号暂存起来
        topo[count++] = i;

        // 遍历i号顶点的邻接点
        for(p = G.vertices[i].firstarc; p != NULL; p = p->nextarc) {
            // 获取顶点序号
            k = p->adjvex;

            /*
             * 将i号顶点每个邻接点的入度减一，这相当于切段i号顶点到其它邻接点的联系。
             * 如果出现了新的入度为0的顶点，继续将其入栈。
             */
            if((--indegree[k]) == 0) {
                Push(&S, k);
            }
        }
    }

    // 如果遇到了回路，则返回ERROR
    if(count < G.vexnum) {
        return ERROR;
    } else {
        return OK;
    }
}

/*
 * 计算各顶点的入度
 */
static void FindInDegree(ALGraph G, int indegree[MAX_VERTEX_NUM]) {
    int i;
    ArcNode* p;

    // 初始化所有顶点的入度为0
    for(i = 0; i < G.vexnum; i++) {
        indegree[i] = 0;
    }

    // 遍历所有顶点
    for(i = 0; i < G.vexnum; i++) {
        // 指向该顶点的首个邻接点
        p = G.vertices[i].firstarc;

        // 遍历该顶点的所有邻接点，统计各顶点的入度
        while(p != NULL) {
            indegree[p->adjvex]++;
            p = p->nextarc;
        }
    }
}

最小生成树

/*
 * 普里姆算法中用到的辅助数组，
 * 用来记录从顶点子集U到顶点子集V-U的代价最小的边
 */
static struct {
    VertexType adjvex;      // 顶点子集U中的顶点
    VRType lowcost;         // 顶点子集V-U到当前顶点的边的权值
} closedge[MAX_VERTEX_NUM]; // 辅助数组


/*
 * ████████ 算法7.9 ████████
 *
 * 普里姆算法
 *
 * 从第u个顶点出发构造无向网G的最小生成树T，输出T的各条边。
 * 该算法的耗时部分是对顶点的遍历，与网中的边数无关，因为适用于边比较稠密的网
 *
 * 注：预设图的权值均大于0，允许调整
 */
void MinSpanTree_PRIM(MGraph G, VertexType u) {
    int i, j, k;

    // 返回顶点u在无向网中的位置
    k = LocateVex(G, u);

    // 辅助数组初始化，将顶点u加入了顶点子集U
    for(j = 0; j < G.vexnum; j++) {
        if(j != k) {
            closedge[j].adjvex = u;
            closedge[j].lowcost = G.arcs[k][j].adj;
        }
    }

    // 赋值为0意味着顶点k已进入顶点子集U
    closedge[k].lowcost = 0;

    // 选择其余G.vexnum-1个顶点
    for(i = 1; i < G.vexnum; i++) {
        // 从顶点子集V-U中选出下一个候选顶点以便后续加入到最小生成树
        k = minimum(G);

        // 打印顶点和边的信息
        printf("%c --%d-- %c\n", closedge[k].adjvex, closedge[k].lowcost, G.vexs[k]);

        // 将顶点k加入到顶点子集U
        closedge[k].lowcost = 0;

        // 新顶点进入顶点子集U后，需要更新顶点子集U与顶点子集V-U的边的信息
        for(j = 0; j < G.vexnum; j++) {
            if(G.arcs[k][j].adj < closedge[j].lowcost) {
                closedge[j].adjvex = G.vexs[k];
                closedge[j].lowcost = G.arcs[k][j].adj;
            }
        }
    }
}

/*
 * 从顶点子集V-U中选出下一个候选顶点以便后续加入到最小生成树
 *
 * 选择顶点子集U到顶点子集V-U的权值最小的边，
 * 并返回该边在顶点子集V-U中那头的端点，
 * 该端点后续会加入到顶点子集U中，成为最小生成树的新结点。
 *
 * 注：形参与教材中给出的模板有所不同
 */
static int minimum(MGraph G) {
    int i, k = -1;
    int min = INT_MAX;

    // 从权值不为0的边中选择拥有最小权值的边
    for(i = 0; i < G.vexnum; i++) {
        if(closedge[i].lowcost != 0 && closedge[i].lowcost < min) {
            min = closedge[i].lowcost;
            k = i;
        }
    }

    return k;
}

/*
 * 克鲁斯卡尔算法
 *
 * 从第u个顶点出发构造无向网G的最小生成树T，输出T的各条边
 * 该算法的耗时部分是对边的遍历，与网中的顶点无关，因为适用于边比较稀疏的网
 *
 * 可以改进之处：对已有边排序时可以采用第9章介绍的堆排序
 */
void MinSpanTree_KRUSKAL(MGraph G) {
    int i, j, k;
    int s1, s2;

    // 边集
    struct Edge {
        int v1;         // 顶点1的下标
        int v2;         // 顶点2的下标
        VRType adj;     // 权值
    } * edges, tmp;

    // 记录已经加入到最小生成树的顶点集，这里使用集合的目的是快速判断候选顶点是否会造成环路
    MFSet S;
    Relation relation;

    // 边集的容量就是边的数量
    edges = (struct Edge*)malloc(G.arcnum* sizeof(struct Edge));

    // 对边计数
    k = 0;

    // 获取所有的边
    for(i = 0; i < G.vexnum; i++) {
        // 由于网是无向的，所以只遍历一半的边就可以
        for(j = 0; j <= i; j++) {
            // 只对有效的边进行统计
            if(G.arcs[i][j].adj != INFINITE) {
                edges[k].v1 = i;
                edges[k].v2 = j;
                edges[k].adj = G.arcs[i][j].adj;
                k++;
            }
        }
    }

    // 根据权值从小到大对边进行排序，这里只是简单使用了效率较低的冒泡排序
    for(i = 0; i < G.arcnum - 1; i++) {
        for(j = 0; j < G.arcnum - i - 1; j++) {
            // 每轮遍历都将权值大的往后挪
            if(edges[j].adj > edges[j + 1].adj) {
                tmp = edges[j];
                edges[j] = edges[j + 1];
                edges[j + 1] = tmp;
            }
        }
    }

    // 初始化顶点集合
    initial_mfset(&S, G.vexnum);

    // 从边集中依次选择权值最小，且不构成环路的边加入到最小生成树
    for(i = 0; i < G.arcnum; i++) {
        s1 = find_mfset(S, edges[i].v1);
        s2 = find_mfset(S, edges[i].v2);

        // 如果这两个端点位于同一个集合，则跳过该条边
        if(s1 == s2) {
            continue;
        }

        // 构造二元关系
        relation.n = 1;
        relation.pairs[0].i = edges[i].v1;
        relation.pairs[0].j = edges[i].v2;

        build_mfset(&S, relation);

        // 打印顶点和边的信息
        printf("%c --%d-- %c\n", GetVex(G, edges[i].v1), edges[i].adj, GetVex(G, edges[i].v2));
    }
}

关键活动

/* 全局变量 */
static int ve[MAX_VERTEX_NUM];  // 各事件（顶点）的最早发生时间(越早越好)
static int vl[MAX_VERTEX_NUM];  // 各事件（顶点）的最晚发生时间(越晚越好)

/*
 * ████████ 算法7.14 ████████
 *
 * 计算有向网G的关键路径
 *
 * 注：有向网顶点序列中最后一个顶点必须为事件终点
 */
Status CriticalPath(ALGraph G) {
    int i, j, k;
    ArcNode* p;
    SqStack T;  // 拓扑序列顶点栈
    int dut;    // 活动持续时间
    int ee, el;
    char tag;
    int count;

    int path[MAX_VERTEX_NUM];           // 存储拓扑序列，跟T中存储的信息一致
    Boolean P[MAX_VERTEX_NUM]= {FALSE}; // 存储关键路径信息，只是为了最后的展示

    // 如果有向网存在回路，则无法计算其拓扑序列，进而也无法得出该有向网的关键路径
    if(!TopologicalOrder(G, &T)) {
        printf("异常退出：给定的有向网中存在回路，故无法生成完整的拓扑序列...\n");
        return ERROR;
    } else {
        printf("有向网的拓扑序列构建成功...\n");
        // 复制拓扑序列到path中以便后续输出
        for(i=0; i<StackLength(T); i++) {
            path[i] = T.base[i];
        }
    }

    // 初始化各事件的最晚发生时间为所有事件中最晚出现的那个最早发生时间(拓扑序列上最后一个事件的最早发生时间)
    for(i = 0; i < G.vexnum; i++) {
        vl[i] = ve[G.vexnum-1]; // ve[G.vexnum-1]代表终点的最早发生时间
    }

    // 逆序遍历拓扑序列顶点栈(将栈中顶点出栈即可达到逆序的目的)
    while(!StackEmpty(T)) {
        // 获取一个顶点
        Pop(&T, &j);

        // 遍历j顶点的邻接点
        for(p = G.vertices[j].firstarc; p != NULL; p = p->nextarc) {
            k = p->adjvex;              // 顶点j的邻接点序号
            dut = (*(p->info)).weight;  // j->k的权值，即事件j->k的持续时间

            // 将事件j的最晚发生时间提前
            if(vl[k] - dut < vl[j]) {
                vl[j] = vl[k] - dut;
            }
        }
    }

    count = 0;

    printf("计算有向网的关键路径信息...\n");

    // 遍历所有顶点
    for(j = 0; j < G.vexnum; j++) {
        // 遍历j顶点的邻接点
        for(p = G.vertices[j].firstarc; p != NULL; p = p->nextarc) {
            k = p->adjvex;
            dut = (*(p->info)).weight;

            ee = ve[j];         // 事件j的最早发生时间
            el = vl[k] - dut;   // 事件j的最晚发生时间

            // 用*标记关键路径
            tag = (ee == el) ? '*' : ' ';

            printf("%c-%c  a%-2d=%2d  (%2d, %2d)  %c\n", G.vertices[j].data, G.vertices[k].data, count++, dut, ee, el, tag);

            // 记录哪些顶点加入到了关键路径中
            if(tag=='*') {
                P[j] = TRUE;
                P[k] = TRUE;
            }
        }
    }


    /*
     * 注：教材中没有后续步骤
     * 此处增加这些步骤是为了更直观地显示关键路径信息
     */
    printf("\n");
    printf("当前有向网的关键路径为：");
    for(i = 0; i < G.vexnum; i++) {
        if(P[path[i]] == TRUE) {
            printf("%c ", G.vertices[path[i]].data);
        }
    }
    printf("\n");

    return OK;
}

/*
 * ████████ 算法7.13 ████████
 *
 * 如果有向网G无回路，则寻找它的一个拓扑序列存储到拓扑序列栈T中，并返回OK；否则，返回FALSE。
 * 拓扑序列通常不唯一，但是必须保证某些关键节点的先后次序。
 */
static Status TopologicalOrder(ALGraph G, SqStack* T) {
    int i, j, k, count;
    int indegree[MAX_VERTEX_NUM + 1];
    SqStack S;
    ArcNode* p;

    // 对各顶点求入度
    FindInDegree(G, indegree);

    // 初始化零入度顶点栈
    InitStack(&S);

    // 初始化拓扑序列顶点栈
    InitStack(T);

    // 建立入度为0的顶点栈
    for(i = 0; i < G.vexnum; i++) {
        // 将入度为0的顶点添加到栈中
        if(indegree[i] == 0) {
            Push(&S, i);
        }

        // 初始化零入度顶点(事件)的最早发生时间为0
        ve[i] = 0;
    }

    // 对拓扑序列中的顶点计数
    count = 0;

    // 遍历顶点栈
    while(!StackEmpty(S)) {
        // 获取一个零入度顶点
        Pop(&S, &j);

        // 将该顶点加入到拓扑序列顶点栈中
        Push(T, j);

        count++;

        // 遍历i号顶点的邻接点
        for(p = G.vertices[j].firstarc; p != NULL; p = p->nextarc) {
            // 将j号顶点每个邻接点的入度减一，这相当于切段j号顶点到其它邻接点的联系
            k = p->adjvex;

            // 如果出现了新的入度为0的顶点，继续将其入栈
            if((--indegree[k]) == 0) {
                Push(&S, k);
            }

            // 计算邻接点事件的最早发生时间
            if(ve[j] + (*(p->info)).weight > ve[k]) {
                ve[k] = ve[j] + (*(p->info)).weight;
            }
        }
    }

    // 如果遇到了回路，则返回ERROR
    if(count < G.vexnum) {
        return ERROR;
    } else {
        return OK;
    }
}

/*
 * 计算各顶点的入度
 */
static void FindInDegree(ALGraph G, int indegree[MAX_VERTEX_NUM]) {
    int i;
    ArcNode* p;

    // 初始化所有顶点的入度为0
    for(i = 0; i < G.vexnum; i++) {
        indegree[i] = 0;
    }

    // 遍历所有顶点
    for(i = 0; i < G.vexnum; i++) {
        // 指向该顶点的首个邻接点
        p = G.vertices[i].firstarc;

        // 遍历该顶点的所有邻接点，统计各顶点的入度
        while(p != NULL) {
            indegree[p->adjvex]++;
            p = p->nextarc;
        }
    }
}

/*
 * ████████ 算法7.15 ████████
 *
 * 迪杰斯特拉(Dijkstra)算法求单源最短路径
 *
 * @param G  待遍历的图。
 * @param v0 单源最短路径的起点。
 * @param P  存储从v0到其余各顶点的最短路径信息。
 *           P[j][k]==TRUE代表从v0->j的最短路径会经过顶点k；否则，代表不经过。
 *           注：
 *           1.该数组只反映了顶点的存在性，而未反映顶点在路径上的次序。
 *           2.如果两顶点之间有多条最短路径，只会选取一条
 * @param D  存储从v0到其余各顶点的最短路径代价，在图中，该代价是步长和，在网中，该代价是权值和。
 */
void ShortestPath_DIJ(MGraph G, int v0, PathMatrix_DIJ P, ShortPathTable_DIJ D) {
    int v, w, i, j, min;
    Status final[MAX_VERTEX_NUM];   // 用来标记当前结点是否已经访问过，即是否已加入最短路径

    /*
     * 预设已访问过的顶点集为S，未访问过的顶点集为V-S
     * 初始时，顶点集S为空，而顶点集V-S为所有顶点的集合V
     */
    for(v = 0; v < G.vexnum; v++) {
        // 初始时，所有顶点均未访问过
        final[v] = FALSE;

        // 初始化v0->v的路径代价
        D[v] = G.arcs[v0][v].adj;

        // 预设从v0->v不需要经过顶点w，即设空路径
        for(w = 0; w < G.vexnum; w++) {
            P[v][w] = FALSE;
        }

        // 如果是网，只走此分支(教材只处理了此种情形)
        if(G.kind == DN || G.kind == UDN) {
            // 如果v0->v直接连通
            if(D[v] < INFINITE) {
                P[v][v0] = TRUE;    // 指示v0->v必将经过顶点v0(端点一)
                P[v][v] = TRUE;     // 指示v0->v必将经过顶点v(端点二)
            }
        }

        // 如果是图，只走此分支
        if(G.kind == DG || G.kind == UDG) {
            // 如果v0到v直接连通
            if(D[v] != 0) {
                P[v][v0] = TRUE;    // 指示v0->v必将经过顶点v0(端点一)
                P[v][v] = TRUE;     // 指示v0->v必将经过顶点v(端点二)
            }
        }
    }

    // 初始化，v0进入顶点集S
    D[v0] = 0;
    final[v0] = TRUE;

    /*
     * 开始主循环，遍历其余G1.vexnum-1个顶点。
     * 每次求得v0到某个顶点的最短路径，则将该顶点从顶点集V-S中挪到顶点集S中
     */
    for(i = 1; i < G.vexnum; i++) {
        /*
         * 每次进入选取最近顶点之前，都应当将v重置为一个正常顶点序号之外的值
         * (教材中无此步骤，需要补上，否则会进行很多次无效的循环)
         */
        v = -1;

        // 记录各顶点与顶点v0的最短距离
        min = INFINITE;

        // 遍历顶点集V-S(所有未加入路径的顶点)，从中选出距离v0更近的顶点
        for(w = 0; w < G.vexnum; w++) {
            // 如果w顶点在V-S中(未加入最短路径)
            if(!final[w]) {
                // 对于图来说，距离为0意味着两顶点不连通
                if((G.kind == DG || G.kind == UDG) && D[w] == 0) {
                    continue;
                }

                // 如果v0到w的距离D[w]小于当前预设的最小距离，则需要更新顶点和距离信息
                if(D[w] < min) {
                    v = w;      // 记下未访问的顶点中距离v0更近的顶点，或者可以理解为记下顶点集V-S中距离顶点集S更近的顶点
                    min = D[w]; // 记下更近的距离
                }
            }
        }

        // 找到了更近的顶点
        if(v != -1) {
            // 将顶点集V-S中当前距离v0顶点最近的v加入S集
            final[v] = TRUE;
        } else {
            // 如果没找到更近的顶点，说明顶点v0与V-S中的剩余顶点没有连接，此时可以直接结束程序了
            return;
        }

        // 以上述的顶点v做跳板，更新顶点v0到V-S集中其余点顶点的最短路径
        for(w = 0; w < G.vexnum; w++) {
            // 如果是网，只走此分支(教材只处理了此种情形)
            if(G.kind == DN || G.kind == UDN) {
                /*
                 * 为了避免溢出，需要确保G.arcs[v][w].adj不为INFINITE。
                 * 此处其实没必要判断min!=INFINITE，因为如果没找到更近的顶点时，上面就提前返回了。
                 * (教材的伪码中未处理溢出，故需要自行添加)
                 */
                if(min != INFINITE && G.arcs[v][w].adj != INFINITE) {
                    // 更新顶点集S到顶点集V-S的最近距离
                    if(!final[w] && (min + G.arcs[v][w].adj < D[w])) {
                        // 更新距离：由于顶点v0->w经由v后会获得更短的距离，故此处需要记下该距离
                        D[w] = min + G.arcs[v][w].adj;

                        /* 更新路径：P[w] = P[v] + [w] */

                        // 先将v0->w的路径更新为v0->j的路径
                        for(j = 0; j < G.vexnum; j++) {
                            P[w][j] = P[v][j];
                        }

                        // 再将w添加到v0->w的路径中
                        P[w][w] = TRUE;
                    }
                }
            }

            // 如果是图，只走此分支
            if(G.kind == DG || G.kind == UDG) {
                // 更新顶点集S到顶点集V-S的最近距离
                if(!final[w] && G.arcs[v][w].adj != 0 && D[w] == 0) {
                    // 更新距离：由于顶点v0->w经由v后会获得更短的距离，故此处需要记下该距离
                    D[w] = D[v] + 1;    // 图中相邻顶点步长为1

                    /* 更新路径：P[w] = P[v] + [w] */

                    // 先将v0->w的路径更新为v0->j的路径
                    for(j = 0; j < G.vexnum; j++) {
                        P[w][j] = P[v][j];
                    }

                    // 再将w添加到v0->w的路径中
                    P[w][w] = TRUE;
                }
            }
        }
    }
}

/*
 * 打印使用迪杰斯特拉(Dijkstra)算法求取的单源最短路径
 */
void PrintPath_DIJ(MGraph G, int v0, PathMatrix_DIJ P, ShortPathTable_DIJ D) {
    int j;

    // 遍历所有路径
    for(j = 0; j < G.vexnum; j++) {
        if(P[j][v0] == FALSE) {
            printf("%c 到 %c 之间没有通路\n", GetVex(G, v0), GetVex(G, j));
            continue;
        }

        printf("%c 到 %c 之间的最短距离为%2d，其最短路径为：", GetVex(G, v0), GetVex(G, j), D[j]);

        /*
         * 将v0->j之间的无序顶点排列成一条有序路径后打印
         * P[i]指示v0->j这条路径上经过的顶点
         */
        PrintPath(G, v0, j, P[j]);
    }
}

/*
 * ████████ 算法7.16 ████████
 *
 * 弗洛伊德(Floyd)算法求多源最短路径
 *
 * @param G  待遍历的图。
 * @param P  存储各对顶点之间的最短路径信息。
 *           P[i][j][k]==TRUE代表从i->j的最短路径会经过顶点k；否则，代表不经过。
 *           注：该数组只反映了顶点的存在性，而未反映顶点在路径上的次序。
 * @param D  存储各对顶点之间的最短路径代价，在图中，该代价是步长和，在网中，该代价是权值和。
 */
void ShortestPath_FLOYD(MGraph G, PathMatrix_FLOYD P, ShortPathTable_FLOYD D) {
    int i, v, w, u;

    // 对各顶点之间初始已知路径及距离
    for(v = 0; v < G.vexnum; v++) {
        for(w = 0; w < G.vexnum; w++) {
            // 获取<v,w>的边/弧信息
            D[v][w] = G.arcs[v][w].adj;

            // 初始化路径v->w为空路径
            for(u = 0; u < G.vexnum; u++) {
                P[v][w][u] = FALSE;
            }

            // 如果是网，只走此分支(教材只处理了此种情形)
            if(G.kind == DN || G.kind == UDN) {
                // 如果v0->v直接连通
                if(D[v][w] < INFINITE) {
                    P[v][w][v] = TRUE;  // 指示v->w必将经过顶点v(端点一)
                    P[v][w][w] = TRUE;  // 指示v->w必将经过顶点w(端点二)
                }
            }

            // 如果是图，只走此分支
            if(G.kind == DG || G.kind == UDG) {
                // 如果v0->v直接连通
                if(D[v][w] != 0) {
                    P[v][w][v] = TRUE;  // 指示v->w必将经过顶点v(端点一)
                    P[v][w][w] = TRUE;  // 指示v->w必将经过顶点w(端点二)
                }
            }
        }
    }

    for(u = 0; u < G.vexnum; u++) {
        for(v = 0; v < G.vexnum; v++) {
            for(w = 0; w < G.vexnum; w++) {
                // 对于同一顶点，将其视为不连通
                if(v == w) {
                    continue;
                }

                // 如果是网，只走此分支(教材只处理了此种情形)
                if(G.kind == DN || G.kind == UDN) {
                    // 需要先判断权值信息，防止溢出
                    if(D[v][u] != INFINITE && D[u][w] != INFINITE) {
                        // 从v经u到w(v->u->w)的一条路径更短
                        if(D[v][u] + D[u][w] < D[v][w]) {
                            // 更新权值
                            D[v][w] = D[v][u] + D[u][w];

                            // 更新路径
                            for(i = 0; i < G.vexnum; i++) {
                                P[v][w][i] = P[v][u][i] || P[u][w][i];
                            }
                        }
                    }
                }

                // 如果是图，只走此分支
                if(G.kind == DG || G.kind == UDG) {
                    // 需要先判断连接信息
                    if(D[v][u] != 0 && D[u][w] != 0) {
                        // 从v经u到w(v->u->w)的一条路径更短
                        if(D[v][w] == 0 || D[v][u] + D[u][w] < D[v][w]) {
                            // 更新权值
                            D[v][w] = D[v][u] + D[u][w];

                            // 更新路径
                            for(i = 0; i < G.vexnum; i++) {
                                P[v][w][i] = P[v][u][i] || P[u][w][i];
                            }
                        }
                    }
                }
            }
        }
    }
}

/*
 * 打印使用弗洛伊德(Floyd)算法求取的单源最短路径
 */
void PrintPath_FLOYD(MGraph G, PathMatrix_FLOYD P, ShortPathTable_FLOYD D) {
    int i, j;

    // 遍历所有路径
    for(i = 0; i < G.vexnum; i++) {
        for(j = 0; j < G.vexnum; j++) {
            if(P[i][j][i] == FALSE) {
                printf("%c 到 %c 之间没有通路\n", GetVex(G, i), GetVex(G, j));
                continue;
            }

            printf("%c 到 %c 之间的最短距离为%2d，其最短路径为：", GetVex(G, i), GetVex(G, j), D[i][j]);

            /*
             * 将i->j之间的无序顶点排列成一条有序路径后打印
             * P[i][j]指示i->j这条路径上经过的顶点
             */
            PrintPath(G, i, j, P[i][j]);
        }
    }
}

/*
 * 打印从a到b的路径，该路径的顶点信息位于P中
 */
static void PrintPath(MGraph G, int a, int b, Boolean P[MAX_VERTEX_NUM]) {
    int i;
    int vexs[MAX_VERTEX_NUM + 1];
    int path[MAX_VERTEX_NUM + 1];

    vexs[0] = 0;

    // 获取v0->i这条途径上的所有顶点，可能是无序的
    for(i = 0; i < G.vexnum; i++) {
        if(P[i] == TRUE) {
            vexs[0]++;
            vexs[vexs[0]] = i;
        }
    }

    // 只有两个顶点的情形下快速处理
    if(vexs[0] == 2) {
        path[0] = 2;
        path[1] = a;
        path[2] = b;
        goto print;
    }

    // 只有三个顶点的情形下快速处理
    if(vexs[0] == 3) {
        path[0] = 3;
        path[1] = a;
        for(i = 1; i <= vexs[0]; i++) {
            if(vexs[i] != a && vexs[i] != b) {
                path[2] = vexs[i];
                break;
            }
        }
        path[3] = b;
        goto print;
    }

    path[0] = 1;
    path[1] = a;

    for(i = 1; i <= vexs[0]; i++) {
        if(vexs[i] == a) {
            vexs[i] = -1;
            break;
        }
    }

    Find(G, a, b, vexs, path);

print:
    // 打印排列好的路径
    for(i = 1; i <= path[0]; i++) {
        printf("%c ", GetVex(G, path[i]));
    }

    printf("\n");
}

/*
 * 利用广度预先搜索找到一条从pre到b的路径，该路径上路过的所有顶点位于vexs中，找出的路径存储到path中
 */
static Status Find(MGraph G, int pre, int b, int vexs[MAX_VERTEX_NUM + 1], int path[MAX_VERTEX_NUM + 1]) {
    int i;
    int tmp;
    Status s;

    for(i = 1; i <= vexs[0]; i++) {
        // 已加入到路径
        if(vexs[i] == -1) {
            continue;
        }

        // 不连通
        if(((G.kind == DN || G.kind == UDN) && G.arcs[pre][vexs[i]].adj == INFINITE)
        || ((G.kind == DG || G.kind == UDG) && G.arcs[pre][vexs[i]].adj == 0)) {
            continue;
        }

        path[0]++;
        path[path[0]] = vexs[i];

        // 遇到终点
        if(vexs[i] == b) {
            // 找到了最短路径
            if(path[0] == vexs[0]) {
                return OK;
            } else {
                path[0]--;
                continue;
            }
        }

        tmp = vexs[i];
        vexs[i] = -1;

        s = Find(G, tmp, b, vexs, path);

        if(s == OK) {
            return OK;
        } else {
            // 恢复该顶点，以便后续重新搜索
            vexs[i] = tmp;
            path[0]--;
        }
    }

    return ERROR;
}

第九章 查找

折半查找、顺序查找

/* 折半查找 */
int Binary_Search(int *a,int n,int key)
{
    int low,high,mid;
    low=1;    /* 定义最低下标为记录首位 */
    high=n;    /* 定义最高下标为记录末位 */
    while(low<=high)
    {
        mid=(low+high)/2;    /* 折半 */
        if (key<a[mid])        /* 若查找值比中值小 */
            high=mid-1;        /* 最高下标调整到中位下标小一位 */
        else if (key>a[mid])/* 若查找值比中值大 */
            low=mid+1;        /* 最低下标调整到中位下标大一位 */
        else
        {
            return mid;        /* 若相等则说明mid即为查找到的位置 */
        }

    }
    return 0;
}

/* 无哨兵顺序查找，a为数组，n为要查找的数组个数，key为要查找的关键字 */
int Sequential_Search(int *a,int n,int key)
{
    int i;
    for(i=1;i<=n;i++)
    {
        if (a[i]==key)
            return i;
    }
    return 0;
}
/* 有哨兵顺序查找 */
int Sequential_Search2(int *a,int n,int key)
{
    int i;
    a[0]=key;
    i=n;
    while(a[i]!=key)
    {
        i--;
    }
    return i;
}

哈希表（线性探测法解决冲突）

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100 /* 存储空间初始分配量 */

#define SUCCESS 1
#define UNSUCCESS 0
#define HASHSIZE 12 /* 定义散列表长为数组的长度 */
#define NULLKEY -32768 

typedef int Status;    /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ 

typedef struct
{
   int *elem; /* 数据元素存储基址，动态分配数组 */
   int count; /*  当前数据元素个数 */
}HashTable;

int m=0; /* 散列表表长，全局变量 */

/* 初始化散列表 */
Status InitHashTable(HashTable *H)
{
    int i;
    m=HASHSIZE;
    H->count=m;
    H->elem=(int *)malloc(m*sizeof(int));
    for(i=0;i<m;i++)
        H->elem[i]=NULLKEY; 
    return OK;
}

/* 散列函数 */
int Hash(int key)
{
    return key % m; /* 除留余数法 */
}

/* 插入关键字进散列表 */
void InsertHash(HashTable *H,int key)
{
    int addr = Hash(key); /* 求散列地址 */
    while (H->elem[addr] != NULLKEY) /* 如果不为空，则冲突 */
    {
        addr = (addr+1) % m; /* 开放定址法的线性探测 */
    }
    H->elem[addr] = key; /* 直到有空位后插入关键字 */
}

/* 散列表查找关键字 */
Status SearchHash(HashTable H,int key,int *addr)
{
    *addr = Hash(key);  /* 求散列地址 */
    while(H.elem[*addr] != key) /* 如果不为空，则冲突 */
    {
        *addr = (*addr+1) % m; /* 开放定址法的线性探测 */
        if (H.elem[*addr] == NULLKEY || *addr == Hash(key)) /* 如果循环回到原点 */
            return UNSUCCESS;    /* 则说明关键字不存在 */
    }
    return SUCCESS;
}
  • 二叉排序树（平均查找长度）__* ```c / 二叉树的二叉链表结点结构定义 / typedef struct BiTNode / 结点结构 / { int data; / 结点数据 / struct BiTNode lchild, rchild; / 左右孩子指针 / } BiTNode, *BiTree;

/ 递归查找二叉排序树T中是否存在key, / / 指针f指向T的双亲，其初始调用值为NULL / / 若查找成功，则指针p指向该数据元素结点，并返回TRUE / / 否则指针p指向查找路径上访问的最后一个结点并返回FALSE / Status SearchBST(BiTree T, int key, BiTree f, BiTree p) {
if (!T) / 查找不成功 / { p = f;
return FALSE; } else if (key==T->data) / 查找成功 / { p = T;
return TRUE; } else if (keydata) return SearchBST(T->lchild, key, T, p); / 在左子树中继续查找 / else
return SearchBST(T->rchild, key, T, p); / 在右子树中继续查找 */ }

/ 当二叉排序树T中不存在关键字等于key的数据元素时， / / 插入key并返回TRUE，否则返回FALSE / Status InsertBST(BiTree T, int key) {
BiTree p,s; if (!SearchBST(T, key, NULL, &p)) / 查找不成功 / { s = (BiTree)malloc(sizeof(BiTNode)); s->data = key;
s->lchild = s->rchild = NULL;
if (!p) T = s; / 插入s为新的根结点 / else if (keydata) p->lchild = s; / 插入s为左孩子 / else p->rchild = s; / 插入s为右孩子 / return TRUE; } else return FALSE; / 树中已有关键字相同的结点，不再插入 */ }

/ 从二叉排序树中删除结点p，并重接它的左或右子树。 / Status Delete(BiTree p) { BiTree q,s; if((p)->rchild==NULL) / 右子树空则只需重接它的左子树（待删结点是叶子也走此分支) / { q=p; p=(p)->lchild; free(q); } else if((p)->lchild==NULL) / 只需重接它的右子树 / { q=p; p=(p)->rchild; free(q); } else / 左右子树均不空 / { q=p; s=(p)->lchild; while(s->rchild) / 转左，然后向右到尽头（找待删结点的前驱） / { q=s; s=s->rchild; } (p)->data=s->data; / s指向被删结点的直接前驱（将被删结点前驱的值取代被删结点的值） / if(q!=p) q->rchild=s->lchild; / 重接q的右子树 / else q->lchild=s->lchild; / 重接q的左子树 */ free(s); } return TRUE; }

/ 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点, / / 并返回TRUE；否则返回FALSE。 / Status DeleteBST(BiTree T,int key) { if(!T) / 不存在关键字等于key的数据元素 / return FALSE; else { if (key==(T)->data) / 找到关键字等于key的数据元素 / return Delete(T); else if (key<(T)->data) return DeleteBST(&(T)->lchild,key); else return DeleteBST(&(T)->rchild,key);

}

}



**_AVL树（平衡因子）_**
```c
/* 二叉树的二叉链表结点结构定义 */
typedef  struct BiTNode    /* 结点结构 */
{
    int data;    /* 结点数据 */
    int bf; /*  结点的平衡因子 */ 
    struct BiTNode *lchild, *rchild;    /* 左右孩子指针 */
} BiTNode, *BiTree;


/* 对以p为根的二叉排序树作右旋处理， */
/* 处理之后p指向新的树根结点，即旋转处理之前的左子树的根结点 */
void R_Rotate(BiTree *P)
{ 
    BiTree L;
    L=(*P)->lchild; /*  L指向P的左子树根结点 */ 
    (*P)->lchild=L->rchild; /*  L的右子树挂接为P的左子树 */ 
    L->rchild=(*P);
    *P=L; /*  P指向新的根结点 */ 
}

/* 对以P为根的二叉排序树作左旋处理， */
/* 处理之后P指向新的树根结点，即旋转处理之前的右子树的根结点0  */
void L_Rotate(BiTree *P)
{ 
    BiTree R;
    R=(*P)->rchild; /*  R指向P的右子树根结点 */ 
    (*P)->rchild=R->lchild; /* R的左子树挂接为P的右子树 */ 
    R->lchild=(*P);
    *P=R; /*  P指向新的根结点 */ 
}

#define LH +1 /*  左高 */ 
#define EH 0  /*  等高 */ 
#define RH -1 /*  右高 */ 

/*  对以指针T所指结点为根的二叉树作左平衡旋转处理 */
/*  本算法结束时，指针T指向新的根结点 */
void LeftBalance(BiTree *T)
{ 
    BiTree L,Lr;
    L=(*T)->lchild; /*  L指向T的左子树根结点 */ 
    switch(L->bf)
    { /*  检查T的左子树的平衡度，并作相应平衡处理 */ 
         case LH: /*  新结点插入在T的左孩子的左子树上，要作单右旋处理 */ 
            (*T)->bf=L->bf=EH;
            R_Rotate(T);
            break;
         case RH: /*  新结点插入在T的左孩子的右子树上，要作双旋处理 */ 
            Lr=L->rchild; /*  Lr指向T的左孩子的右子树根 */ 
            switch(Lr->bf)
            { /*  修改T及其左孩子的平衡因子 */ 
                case LH: (*T)->bf=RH;
                         L->bf=EH;
                         break;
                case EH: (*T)->bf=L->bf=EH;
                         break;
                case RH: (*T)->bf=EH;
                         L->bf=LH;
                         break;
            }
            Lr->bf=EH;
            L_Rotate(&(*T)->lchild); /*  对T的左子树作左旋平衡处理 */ 
            R_Rotate(T); /*  对T作右旋平衡处理 */ 
    }
}

/*  对以指针T所指结点为根的二叉树作右平衡旋转处理， */ 
/*  本算法结束时，指针T指向新的根结点 */ 
void RightBalance(BiTree *T)
{ 
    BiTree R,Rl;
    R=(*T)->rchild; /*  R指向T的右子树根结点 */ 
    switch(R->bf)
    { /*  检查T的右子树的平衡度，并作相应平衡处理 */ 
     case RH: /*  新结点插入在T的右孩子的右子树上，要作单左旋处理 */ 
              (*T)->bf=R->bf=EH;
              L_Rotate(T);
              break;
     case LH: /*  新结点插入在T的右孩子的左子树上，要作双旋处理 */ 
              Rl=R->lchild;             /*  Rl指向T的右孩子的左子树根 */ 
              switch(Rl->bf)
              {                         /*  修改T及其右孩子的平衡因子 */ 
                case RH: (*T)->bf=LH;
                         R->bf=EH;
                         break;
                case EH: (*T)->bf=R->bf=EH;
                         break;
                case LH: (*T)->bf=EH;
                         R->bf=RH;
                         break;
              }
              Rl->bf=EH;
              R_Rotate(&(*T)->rchild); /*  对T的右子树作右旋平衡处理 */ 
              L_Rotate(T); /*  对T作左旋平衡处理 */ 
    }
}

/*  若在平衡的二叉排序树T中不存在和e有相同关键字的结点，则插入一个 */ 
/*  数据元素为e的新结点，并返回1，否则返回0。若因插入而使二叉排序树 */ 
/*  失去平衡，则作平衡旋转处理，布尔变量taller反映T长高与否。 */
Status InsertAVL(BiTree *T,int e,Status *taller)
{  
    if(!*T)
    { /*  插入新结点，树“长高”，置taller为TRUE */ 
         *T=(BiTree)malloc(sizeof(BiTNode));
         (*T)->data=e; (*T)->lchild=(*T)->rchild=NULL; (*T)->bf=EH;
         *taller=TRUE;
    }
    else
    {
        if (e==(*T)->data)
        { /*  树中已存在和e有相同关键字的结点则不再插入 */ 
            *taller=FALSE; return FALSE;
        }
        if (e<(*T)->data)
        { /*  应继续在T的左子树中进行搜索 */ 
            if(!InsertAVL(&(*T)->lchild,e,taller)) /*  未插入 */ 
                return FALSE;
            if(*taller) /*   已插入到T的左子树中且左子树“长高” */ 
                switch((*T)->bf) /*  检查T的平衡度 */ 
                {
                    case LH: /*  原本左子树比右子树高，需要作左平衡处理 */ 
                            LeftBalance(T);    *taller=FALSE; break;
                    case EH: /*  原本左、右子树等高，现因左子树增高而使树增高 */ 
                            (*T)->bf=LH; *taller=TRUE; break;
                    case RH: /*  原本右子树比左子树高，现左、右子树等高 */  
                            (*T)->bf=EH; *taller=FALSE; break;
                }
        }
        else
        { /*  应继续在T的右子树中进行搜索 */ 
            if(!InsertAVL(&(*T)->rchild,e,taller)) /*  未插入 */ 
                return FALSE;
            if(*taller) /*  已插入到T的右子树且右子树“长高” */ 
                switch((*T)->bf) /*  检查T的平衡度 */ 
                {
                    case LH: /*  原本左子树比右子树高，现左、右子树等高 */ 
                            (*T)->bf=EH; *taller=FALSE;    break;
                    case EH: /*  原本左、右子树等高，现因右子树增高而使树增高  */
                            (*T)->bf=RH; *taller=TRUE; break;
                    case RH: /*  原本右子树比左子树高，需要作右平衡处理 */ 
                            RightBalance(T); *taller=FALSE; break;
                }
        }
    }
    return TRUE;
}

第十章 排序

  • 冒泡排序 __* ```c / 对顺序表L作交换排序（冒泡排序初级版） / void BubbleSort0(SqList *L) { int i,j; for(i=1;ilength;i++) {
      for(j=i+1;j<=L->length;j++)
  {
      if(L->r[i]>L->r[j])
      {
           swap(L,i,j);/* 交换L->r[i]与L->r[j]的值 */
      }
  }
    } }

/ 对顺序表L作冒泡排序 / void BubbleSort(SqList L) { int i,j; for(i=1;ilength;i++) { for(j=L->length-1;j>=i;j—) / 注意j是从后往前循环 / { if(L->r[j]>L->r[j+1]) / 若前者大于后者（注意这里与上一算法的差异）/ { swap(L,j,j+1);/ 交换L->r[j]与L->r[j+1]的值 */ } } } }

/ 对顺序表L作改进冒泡算法 / void BubbleSort2(SqList L) { int i,j; Status flag=TRUE; / flag用来作为标记 / for(i=1;ilength && flag;i++) / 若flag为true说明有过数据交换，否则停止循环 / { flag=FALSE; / 初始为False / for(j=L->length-1;j>=i;j—) { if(L->r[j]>L->r[j+1]) { swap(L,j,j+1); / 交换L->r[j]与L->r[j+1]的值 / flag=TRUE; / 如果有数据交换，则flag为true */ } } } }


- [x] **_快速排序 __*_**
```c
/* 快速排序******************************** */

/* 交换顺序表L中子表的记录，使枢轴记录到位，并返回其所在位置 */
/* 此时在它之前(后)的记录均不大(小)于它。 */
int Partition(SqList *L,int low,int high)
{ 
    int pivotkey;

    pivotkey=L->r[low]; /* 用子表的第一个记录作枢轴记录 */
    while(low<high) /*  从表的两端交替地向中间扫描 */
    { 
         while(low<high&&L->r[high]>=pivotkey)
            high--;
         swap(L,low,high);/* 将比枢轴记录小的记录交换到低端 */
         while(low<high&&L->r[low]<=pivotkey)
            low++;
         swap(L,low,high);/* 将比枢轴记录大的记录交换到高端 */
    }
    return low; /* 返回枢轴所在位置 */
}

/* 对顺序表L中的子序列L->r[low..high]作快速排序 */
void QSort(SqList *L,int low,int high)
{ 
    int pivot;
    if(low<high)
    {
            pivot=Partition(L,low,high); /*  将L->r[low..high]一分为二，算出枢轴值pivot */
            QSort(L,low,pivot-1);        /*  对低子表递归排序 */
            QSort(L,pivot+1,high);        /*  对高子表递归排序 */
    }
}


/* 改进后快速排序******************************** */

/* 快速排序优化算法 */
int Partition1(SqList *L,int low,int high)
{ 
    int pivotkey;

    int m = low + (high - low) / 2; /* 计算数组中间的元素的下标 */  
    if (L->r[low]>L->r[high])            
        swap(L,low,high);    /* 交换左端与右端数据，保证左端较小 */
    if (L->r[m]>L->r[high])
        swap(L,high,m);        /* 交换中间与右端数据，保证中间较小 */
    if (L->r[m]>L->r[low])
        swap(L,m,low);        /* 交换中间与左端数据，保证左端较小 */

    pivotkey=L->r[low]; /* 用子表的第一个记录作枢轴记录 */
    L->r[0]=pivotkey;  /* 将枢轴关键字备份到L->r[0] */
    while(low<high) /*  从表的两端交替地向中间扫描 */
    { 
         while(low<high&&L->r[high]>=pivotkey)
            high--;
         L->r[low]=L->r[high];
         while(low<high&&L->r[low]<=pivotkey)
            low++;
         L->r[high]=L->r[low];
    }
    L->r[low]=L->r[0];
    return low; /* 返回枢轴所在位置 */
}

void QSort1(SqList *L,int low,int high)
{ 
    int pivot;
    if((high-low)>MAX_LENGTH_INSERT_SORT)
    {
        pivot=Partition1(L,low,high); /*  将L->r[low..high]一分为二，算出枢轴值pivot */
        QSort1(L,low,pivot-1);        /*  对低子表递归排序 */
        QSort1(L,pivot+1,high);        /*  对高子表递归排序 */
    }
    else
        InsertSort(L);
}

/* 对顺序表L作快速排序 */
void QuickSort1(SqList *L)
{ 
    QSort1(L,1,L->length);
}

/* 尾递归 */
void QSort2(SqList *L,int low,int high)
{ 
    int pivot;
    if((high-low)>MAX_LENGTH_INSERT_SORT)
    {
        while(low<high)
        {
            pivot=Partition1(L,low,high); /*  将L->r[low..high]一分为二，算出枢轴值pivot */
            QSort2(L,low,pivot-1);        /*  对低子表递归排序 */
            low=pivot+1;    /* 尾递归 */
        }
    }
    else
        InsertSort(L);
}

/* 对顺序表L作快速排序(尾递归) */
void QuickSort2(SqList *L)
{ 
    QSort2(L,1,L->length);
}

/* **************************************** */

直接插入排序

/* 对顺序表L作直接插入排序 */
void InsertSort(SqList *L)
{ 
    int i,j;
    for(i=2;i<=L->length;i++)
    {
        if (L->r[i]<L->r[i-1]) /* 需将L->r[i]插入有序子表 */
        {
            L->r[0]=L->r[i]; /* 设置哨兵 */
            for(j=i-1;L->r[j]>L->r[0];j--)
                L->r[j+1]=L->r[j]; /* 记录后移 */
            L->r[j+1]=L->r[0]; /* 插入到正确位置 */
        }
    }
}

简单选择排序

/* 对顺序表L作简单选择排序 */
void SelectSort(SqList *L)
{
    int i,j,min;
    for(i=1;i<L->length;i++)
    { 
        min = i;                        /* 将当前下标定义为最小值下标 */
        for (j = i+1;j<=L->length;j++)/* 循环之后的数据 */
        {
            if (L->r[min]>L->r[j])    /* 如果有小于当前最小值的关键字 */
                min = j;                /* 将此关键字的下标赋值给min */
        }
        if(i!=min)                        /* 若min不等于i，说明找到最小值，交换 */
            swap(L,i,min);                /* 交换L->r[i]与L->r[min]的值 */
    }
}
  • 排序方法的稳定性 __*