数据结构实践课代码（上）

队列：

#include <stdio.h>
#define max 10
typedef struct st {
    int data[max];
    int rear, front;
} sk;
void csh(sk& s)  // 初始化
{
    s.rear = s.front = 0;
    s.data[0] = 0;
}
bool dk(sk& s)  // 队空
{
    if (s.rear == s.front)
        return true;
    else
        return false;
}
bool dm(sk& s)  // 队满
{
    if ((s.rear + 1) % max == s.front)
        return true;
    else
        return false;
}
void push(sk& s, int e)  // 入队
{
    if (dm(s))
        printf("入队失败");
    else {
        s.rear = (s.rear + 1) % max;
        s.data[s.rear] = e;
    }
}
void pop(sk& s, int e)  // 出队
{
    if (dk(s))
        printf("出队失败");
    else {
        s.front = (s.front + 1) % max;
        e = s.data[s.front];
    }
}
void sc(sk s)  // 输出队列
{
    int i;
    for (i = s.front; i != s.rear; i = (i + 1) % max) {
        printf("%d  ", s.data[i]);
    }
    printf("%d", s.data[i]);
}

int main() {
    sk s;
    csh(s);
    int e;  // 赋值
    scanf("%d", &e);
    while (e != 0) {
        push(s, e);
        scanf("%d", &e);
    }
    int i;  // 操作
    scanf("%d", &i);
    switch (i) {
        case 1:
            scanf("%d", &e);
            push(s, e);
            sc(s);
            break;
        case 2:
            pop(s, e);
            printf("%d", e);
            sc(s);
            break;
    }
}

栈:

#include <stdio.h>
#include <stdlib.h>
#define max 10
#define error 0
typedef struct st {
    char data[max];
    int top;
} sk;
void zk(sk& s)  // 置空栈
{
    s.top = -1;
}
bool sfwm(sk s)  // 是否为满
{
    return (s.top == max - 1 ? true : false);
}
void push(sk& s, char e)  // 存
{
    if (sfwm(s))
        printf("失败");
    s.top++;
    s.data[s.top] = e;
}
bool sfzk(st s)  // 是否为空
{
    if (s.top == -1)
        return true;
    else
        return false;
}
void pop(sk& s, char& e)  // 取
{
    if (sfzk(s))
        printf("失败");
    e = s.data[s.top];
    s.top--;
}
int main() {
    sk s;
    char ch;
    zk(s);
    while ((ch = getchar()) != '\n') {
        switch (ch) {
            case '(':
            case '[':
            case '{':
                push(s, ch);
                break;
            case ')':
                if (sfzk(s))
                    printf("false");
                else {
                    char e;
                    pop(s, e);
                    if (e != '(')
                        printf("false");
                    break;
                }
            case ']':
                if (sfzk(s))
                    printf("false");
                else {
                    char e;
                    pop(s, e);
                    if (e != '[')
                        printf("false");
                    break;
                }
            case '}':
                if (sfzk(s))
                    printf("false");
                else {
                    char e;
                    pop(s, e);
                    if (e != '{')
                        printf("false");
                }
                break;
            default:
                break;
        }
    }
    if (sfzk(s))
        printf("true");
    else
        printf("false");
}

二叉树

/**
 * 二叉树用链式存储,非数组
 * 哈夫曼树用的是二叉树的存储结构
 * 哈夫曼树中字符串使用动态数组分配,理论上可以无限大小
 * 尽可能少的使用多重循环
 * 遍历非递归算法使用链栈存储,不是用数组模拟
 */
#include "stdio.h"
#include "stdlib.h"
#include "string.h"

// 定义字符为数据
typedef char Data;

// 类型定义
#define __INT64 __INT64_TYPE__
// 有符号整数定义
typedef signed char int8_t;
typedef signed short int int16_t;
typedef signed int int32_t;
typedef signed __INT64 int64_t;

// 无符号整数定义
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;
typedef unsigned int uint32_t;
typedef unsigned __INT64 uint64_t;

// 二叉树结构体
typedef struct BTNode {
    BTNode* lchild;
    BTNode* rchild;
    Data Data;  // 在哈夫曼树中Data代表权值weight
    BTNode* parent;
} BTNode;

// 栈元素结构体
typedef struct Stack_Node {
    BTNode* BT;        // 二叉树指针作为存储元素
    Stack_Node* next;  // 下一个栈位置
} Stack_Node;

// 栈结构体
typedef struct Lnk_Stack {
    Stack_Node* top;  // 栈顶元素指针
    uint8_t len;      // 长度
} Lnk_Stack;

// 字符,权值,哈夫曼编码定义
typedef struct Huff_Char {
    uint8_t weight;  // 权值
    char ch;         // 代表的字符
    char* code;      // 哈夫曼编码
    BTNode* start;   // 在哈夫曼树中二叉树的位置
} Huff_Char;

// 二叉树操作
BTNode* Init_Tree(void);  // 初始化一颗空数,返回结点指针
BTNode* Create_Tree(BTNode* parent);  // 生成一颗二叉树

void DLR_Tree(BTNode* T);  // 先序遍历
void LDR_Tree(BTNode* T);  // 中序遍历
void LRD_Tree(BTNode* T);  // 后序遍历

void DLR_Tree_NR(BTNode* T);  // 先序非递归, NR=No Recursion
void LDR_Tree_NR(BTNode* T);  // 中序非递归
void LRD_Tree_NR(BTNode* T);  // 后序非递归

uint8_t Get_High(BTNode* T);       // 求树的高度
uint8_t Get_Leaf_num(BTNode* T);   // 求叶子结点个数
uint16_t Get_Node_num(BTNode* T);  // 求结点总数

uint8_t code_max_len;   // 用于分配字符串空间
uint8_t Huff_Char_num;  // 编码的字符数

// 哈夫曼树操作
BTNode* Huff_Create(Huff_Char* weight);  // 给定权值创建哈夫曼树
void Huff_Encode(BTNode* Huff_Tree,
                 Huff_Char* Code);  // 通过哈夫曼树编码
char* Huff_Decode(char* code_ch,
                  Huff_Char* Huff_Code);  // 解码,返回解码的字符串

// 栈操作
Lnk_Stack* Init_Stack();
uint8_t LS_Push(Lnk_Stack* LS, BTNode* BT);
BTNode* LS_Pop(Lnk_Stack* LS);
BTNode* LS_Top(Lnk_Stack* LS);  // 访问栈顶元素
// 判空直接用结构体len,定义函数浪费运算资源

int main(void) {
    BTNode* BT;
    // Huff_Char weight[5] = {
    //     {28, 'A'}, {10, 'B'}, {20, 'C'}, {7, 'D'}, {35, 'E'}};
    // Huff_Char Huff_Code[8] = {{5, 'A'},  {29, 'B'}, {7, 'C'}, {8, 'D'},
    //                           {14, 'E'}, {23, 'F'}, {3, 'G'}, {11, 'H'}};
    // uint8_t i;
    // char huff_ch[20];

    // Huff_Char_num = sizeof(Huff_Code) / sizeof(Huff_Code[0]);
    // BT = Huff_Create(Huff_Code);

    // printf("哈夫曼编码如下\n");
    // Huff_Encode(BT, Huff_Code);
    // for (i = 0; i < 8; i++) {
    //     printf("%c->%s ", Huff_Code[i].ch, Huff_Code[i].code);
    // }
    // printf("\n输入三个哈夫曼码文\n");
    // for (i = 0; i < 3; i++) {
    //     scanf("%s", huff_ch);
    //     printf("解码的码文:%s\n", Huff_Decode(huff_ch, Huff_Code));
    // }
    // free(BT);
    // getchar();  // 冲掉回车符
    printf("请输入一个二叉树代码\n");
    BT = Create_Tree(NULL);
    printf("先序遍历");
    DLR_Tree(BT);
    printf(",先序非递归");
    DLR_Tree_NR(BT);
    printf("\n中序");
    LDR_Tree(BT);
    printf(",中序非递归");
    LDR_Tree_NR(BT);
    printf("\n后序遍历");
    LRD_Tree(BT);
    printf(",后序非递归");
    LRD_Tree_NR(BT);
    printf("\n树高度%d\n", Get_High(BT));
    printf("树叶子结点个数%d\n", Get_Leaf_num(BT));
    printf("总结点个数%d\n", Get_Node_num(BT));
    return 0;
}

BTNode* Init_Tree(void) {
    BTNode* T;
    T = (BTNode*)malloc(sizeof(BTNode));
    T->lchild = NULL;
    T->rchild = NULL;
    T->parent = NULL;
    return T;
}
BTNode* Create_Tree(BTNode* parent) {
    BTNode* T;
    char ch;
    scanf("%c", &ch);
    if (ch == '#') {
        T = NULL;
    } else {
        T = Init_Tree();
        T->parent = parent;
        T->Data = ch;
        T->lchild = Create_Tree(T);  // 创建左子树
        T->rchild = Create_Tree(T);  // 创建右子树
    }
    return T;
}
void DLR_Tree(BTNode* T) {
    if (T != NULL) {
        printf("%c ", T->Data);
        DLR_Tree(T->lchild);
        DLR_Tree(T->rchild);
    }
}
void LDR_Tree(BTNode* T) {
    if (T != NULL) {
        LDR_Tree(T->lchild);
        printf("%c ", T->Data);
        LDR_Tree(T->rchild);
    }
}
void LRD_Tree(BTNode* T) {
    if (T != NULL) {
        LRD_Tree(T->lchild);
        LRD_Tree(T->rchild);
        printf("%c ", T->Data);
    }
}
void DLR_Tree_NR(BTNode* T) {
    Lnk_Stack* LS;
    BTNode* p;
    LS = Init_Stack();
    p = T;
    if (T != NULL) {
        LS_Push(LS, T);  // 根节点入栈
        while (LS->top > 0) {
            p = LS_Pop(LS);
            printf("%c ", p->Data);  // 退栈并访问该节点
            if (p->rchild != NULL) {
                LS_Push(LS, p->rchild);  // 右孩子入栈
            }
            if (p->lchild != NULL) {
                LS_Push(LS, p->lchild);  // 左孩子入栈
            }
        }
    }
}
void LDR_Tree_NR(BTNode* T) {
    Lnk_Stack* LS;
    BTNode* p;
    LS = Init_Stack();
    p = T;
    do {
        while (p != NULL) {  // 左节点入栈
            LS_Push(LS, p);
            p = p->lchild;
        }
        if (LS->len > 0) {
            p = LS_Pop(LS);
            printf("%c ", p->Data);
            p = p->rchild;
        }
    } while (p != NULL || LS->top > 0);
}
void LRD_Tree_NR(BTNode* T) {
    Lnk_Stack* LS;
    BTNode* p;
    BTNode* r;
    LS = Init_Stack();
    p = T;
    r = NULL;
    while (p != NULL || LS->top != 0) {
        if (p != NULL) {  // 走到最左边
            LS_Push(LS, p);
            p = p->lchild;
        } else {
            p = LS_Top(LS);
            if (p->rchild != NULL && p->rchild != r) {
                // 若右子树存在且未被访问
                p = p->rchild;  // 向右
            } else {
                p = LS_Pop(LS);  // 出栈访问
                printf("%c ", p->Data);
                r = p;
                p = NULL;
            }
        }
    }
}

uint8_t Get_High(BTNode* T) {
    uint8_t LHigh, RHigh, High;  // 左子树高度, 右子树高度
    if (T == NULL) {
        return 0;  // 空则高度为0
    }
    LHigh = Get_High(T->lchild);
    RHigh = Get_High(T->rchild);
    High = 1 + (LHigh > RHigh ? LHigh : RHigh);
    return High;
}
uint8_t Get_Leaf_num(BTNode* T) {
    if (T == NULL) {
        return 0;
    }
    if (T->lchild == NULL && T->rchild == NULL) {
        return 1;
    }
    return (Get_Leaf_num(T->lchild) + Get_Leaf_num(T->rchild));
}
uint16_t Get_Node_num(BTNode* T) {
    if (T == NULL) {
        return 0;
    }
    return (Get_Node_num(T->lchild) + Get_Node_num(T->rchild) + 1);
}

Lnk_Stack* Init_Stack() {
    Lnk_Stack* LS;
    LS = (Lnk_Stack*)malloc(sizeof(Lnk_Stack));
    LS->top = NULL;
    LS->len = 0;
    return LS;
}
uint8_t LS_Push(Lnk_Stack* LS, BTNode* BT) {
    Stack_Node* LSNode;
    LSNode = (Stack_Node*)malloc(sizeof(Stack_Node));
    LSNode->BT = BT;
    LSNode->next = LS->top;
    LS->top = LSNode;
    LS->len++;
    return 0;
}
BTNode* LS_Pop(Lnk_Stack* LS) {
    BTNode* BT;
    Stack_Node* p;
    if (LS->len == 0) {
        return NULL;
    }
    p = LS->top;
    BT = p->BT;
    LS->top = p->next;
    free(p);
    LS->len--;
    return BT;
}
BTNode* LS_Top(Lnk_Stack* LS) {
    if (LS->len == 0) {
        return NULL;
    }
    return LS->top->BT;
}

BTNode* Huff_Create(Huff_Char* weight) {
    typedef struct Huff_BT {
        BTNode* Tree;
        Huff_BT* next;
        Huff_BT* perior;  // 方便回溯
    } Huff_BT;

    Huff_BT *Head, *p;
    Huff_BT *min, *smin, *max, *temp;  // 最小,次小,最大

    BTNode* tmp;

    uint8_t i, j, t_num = 0;  // 循环变量,集合中树的个数

    Head = (Huff_BT*)malloc(sizeof(Huff_BT));
    min = (Huff_BT*)malloc(sizeof(Huff_BT));
    p = Head;

    // 创建{T1,T2,...}树的集合
    for (i = 0; i < Huff_Char_num; i++) {
        p->Tree = Init_Tree();
        p->Tree->Data = weight[i].weight;  // 权值
        weight[i].start = p->Tree;
        p->next = (Huff_BT*)malloc(sizeof(Huff_BT));
        t_num++;
        p->next->perior = p;
        p = p->next;
    }
    p = p->perior;
    free(p->next);
    p->next = NULL;
    Head->perior = NULL;

    while (t_num != 1) {
        min = Head;
        smin = min->next;
        p = smin->next;
        for (i = 2; i < t_num; i++) {
            // 对三个数max(p),min,smin从小到大排序
            // 得到的min和smin就是最小和次小
            // 如果同时有两个权值相等,与深度大的结合
            max = p;  // 防止干扰p指针

            // 对max,min,smin排序

            if (min->Tree->Data > max->Tree->Data) {
                temp = min;
                min = max;
                max = temp;
            }
            if (smin->Tree->Data > max->Tree->Data) {
                temp = smin;
                smin = max;
                max = temp;
            }
            if (min->Tree->Data > smin->Tree->Data) {
                temp = min;
                min = smin;
                smin = temp;
            }
            // p指针后移
            p = p->next;
        }
        // 交换指针,将smin从集合中释放出来
        if (smin->perior != NULL) {
            smin->perior->next = smin->next;
        } else {
            Head = smin->next;
        }
        if (smin->next != NULL) {
            smin->next->perior = smin->perior;
        } else {
            smin->perior->next = NULL;
        }
        t_num--;
        // min将权值相加放到集合中
        // 小的放左边,大的放右边
        tmp = Init_Tree();

        tmp->lchild = min->Tree;
        min->Tree->parent = tmp;

        tmp->rchild = smin->Tree;
        smin->Tree->parent = tmp;

        tmp->Data = tmp->lchild->Data + tmp->rchild->Data;
        min->Tree = tmp;
    }
    // 当集合中剩余两个元素时不会排序,所以要交换一下
    if (Head->Tree->lchild->Data > Head->Tree->rchild->Data) {
        tmp = Head->Tree->lchild;
        Head->Tree->lchild = Head->Tree->rchild;
        Head->Tree->rchild = tmp;
    }
    code_max_len = Get_High(Head->Tree);
    return Head->Tree;
}
void Huff_Encode(BTNode* Huff_Tree, Huff_Char* Code) {
    uint8_t i, j, len;
    BTNode *p, *q;
    char* code_r;  // 逆序
    code_r = (char*)malloc(sizeof(char) * code_max_len);
    for (i = 0; i < Huff_Char_num; i++) {
        p = Code[i].start;
        q = p->parent;
        for (j = 0; q != NULL; j++) {
            // 如果双亲节点是空,说明是根节点
            if (q->lchild == p) {
                // 左节点为0
                code_r[j] = '0';
            } else {
                // 右节点为1
                code_r[j] = '1';
            }
            p = q;
            q = p->parent;
        }
        len = j;
        Code[i].code = (char*)malloc(sizeof(char) * len);
        for (j = 0; code_r[j] != '\0'; j++) {
            Code[i].code[len - j - 1] = code_r[j];
        }
        Code[i].code[len] = '\0';
    }
}
char* Huff_Decode(char* code_ch, Huff_Char* Huff_Code) {
    uint8_t i_ch, i_huff, i_h, i_deh = 0;
    // 循环变量:读入code的第几个字符,哈夫曼结构体,单个哈夫曼编码匹配,解码字符串
    uint8_t same_num[2];
    // 匹配到相同字符串编码的数量,same_num[0]记录上次匹配的数量,same_num[1]记录本次匹配
    char* out;
    uint8_t* arr_s;  // 匹配到的数组下标
    arr_s = (uint8_t*)malloc(sizeof(uint8_t) * code_max_len);
    out = (char*)malloc(sizeof(char) * (strlen(code_ch) / 2));
    /**
     * 解码思路:
     * 1.读入第n个字符,和编码数组中第n个字符比较
     *   哈夫曼码长度不可能是1
     * 2.如果匹配到前n个字符相同的数量为1,则说明是该字符,匹配完毕,进行下一轮匹配
     *   如果数量为0,则编码错误(不过也不大可能)
     * 3.如果匹配到的数量不为1,记录匹配到的数组下标
     *   遍历匹配到的数组下标,找第三个字符相同的,跟2同理
     * 4.直到匹配到最长编码字符时结束
     */
    for (i_ch = 0; code_ch[i_ch] != '\0';) {
        if (i_h == 0) {
            // 等于0说明是第一次匹配字符串
            // 全部遍历一遍哈夫曼树,找出相同的下标存到arr_s中
            for (i_huff = 0; i_huff < Huff_Char_num; i_huff++) {
                arr_s[i_huff] = i_huff;
            }
            same_num[0] = Huff_Char_num;
        }
        same_num[1] = 0;
        for (i_huff = 0; i_huff < same_num[0]; i_huff++) {
            if (code_ch[i_ch] == Huff_Code[arr_s[i_huff]].code[i_h]) {
                // 匹配到就交换,可以避免直接写入下次找不到的情况
                // 不可能存在i_huff < same[i]的情况
                // arr_s[same_num[1]++] = i_huff;
                // temp = arr_s[same_num[1]];
                arr_s[same_num[1]++] = arr_s[i_huff];
            }
        }
        if (same_num[1] == 0) {
            printf("匹配出错,结果供参考\n");
            break;
        } else if (same_num[1] == 1) {
            i_h = 0;
            out[i_deh] = Huff_Code[arr_s[0]].ch;
            i_deh++;
        } else {
            i_h++;
            same_num[0] = same_num[1];
        }

        i_ch++;
    }
    if (same_num[1] != 1 && same_num[1] != 0) {
        // 哈夫曼编码没有匹配完就跳出循环
        printf("码文可能存在丢失,结果供参考\n");
    }
    return out;
}

图：

#include "stdio.h"
#include "stdlib.h"

#define MAXV 20
#define ERR 255
// 类型定义
#define __INT64 __INT64_TYPE__
// 有符号整数定义
typedef signed char int8_t;
typedef signed short int int16_t;
typedef signed int int32_t;
typedef signed __INT64 int64_t;
// 无符号整数定义
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;
typedef unsigned int uint32_t;
typedef unsigned __INT64 uint64_t;

// 邻接表结构体定义
typedef struct InfoType {
    uint8_t no;
    char info;
} InfoType;

typedef struct ArcNode {
    uint8_t adjvex;  // 顶点下标
    int16_t weight;  // 权值
    ArcNode* next;   // 下一个边
} ArcNode;
typedef struct VertexNode {
    InfoType data;      // 数据域
    ArcNode* firstarc;  // 第一条边指针
} AdjList[MAXV];
typedef struct Graph {
    AdjList adjlist;
    uint8_t vexnum;  // 顶点数
    uint8_t arcnum;  // 边数
} Graph;

// 队列存储
typedef struct Q_Node {
    uint8_t Data;
    Q_Node* next;
} Q_Node;
typedef struct Queue {
    uint16_t Len;  // 队长
    Q_Node* Head;  // 头指针
    Q_Node* Tail;  // 尾指针
} Queue;

// 链队列操作函数
Queue* Init_Queue(void);                // 初始化队列
void En_Queue(Queue* Q, uint8_t data);  // 入队
uint8_t De_Queue(Queue* Q);             // 出队
// 判空不做函数,节省运算资源

// 有向图邻接矩阵函数
Graph* ALG_Create(Graph* G);              // 输入序列创建邻接矩阵
uint8_t Locate_vex(Graph* G, char Data);  // 查找数据相同的下标
uint8_t ALG_Ins(Graph* G);                // 插入边
uint8_t ALG_Del(Graph* G);                // 删除边

uint8_t visited[MAXV];
void ALG_DFS_Trav(Graph* G);  // 深度优先遍历
void ALG_BFS_Trav(Graph* G);  // 广度优先遍历

int main(void) {
    Graph* G;
    G = ALG_Create(G);
    ALG_Ins(G);
    printf("深度优先 ");
    ALG_DFS_Trav(G);
    printf("广度优先 ");
    ALG_BFS_Trav(G);
    printf("删除测试1\n");
    if (ALG_Del(G) != ERR) {
        printf("深度优先 ");
        ALG_DFS_Trav(G);
        printf("广度优先 ");
        ALG_BFS_Trav(G);
    }
    printf("\n删除测试2\n");
    if (ALG_Del(G) != ERR) {
        printf("深度优先 ");
        ALG_DFS_Trav(G);
        printf("广度优先 ");
        ALG_BFS_Trav(G);
    }
    return 0;
}

Queue* Init_Queue(void) {
    Queue* Q;
    Q = (Queue*)malloc(sizeof(Queue));
    Q->Len = 0;
    Q->Head = Q->Tail = NULL;
    return Q;
}
void En_Queue(Queue* Q, uint8_t data) {
    Q_Node* p;
    p = (Q_Node*)malloc(sizeof(Q_Node));
    p->Data = data;
    p->next = Q->Head;
    Q->Head = p;
    if (Q->Len == 0) {
        Q->Tail = p;
    }
    Q->Len++;
}
uint8_t De_Queue(Queue* Q) {
    uint8_t Data;
    Q_Node *p, *q;
    if (Q->Len == 0) {
        return ERR;
    }
    p = Q->Head;
    if (p == Q->Tail) {
        Q->Head = Q->Tail = NULL;
        Data = p->Data;
        free(p);
        Q->Len = 0;
        return Data;
    }
    while (p->next != Q->Tail) {
        p = p->next;
    }
    Q->Tail = p;
    Data = p->next->Data;
    free(p->next);
    p->next = NULL;
    Q->Len--;
    return Data;
}

Graph* ALG_Create(Graph* G) {
    uint8_t i;
    G = (Graph*)malloc(sizeof(Graph));
    printf("输入顶点数和边数\n");
    scanf("%d %d", &G->vexnum, &G->arcnum);
    printf("输入顶点\n");
    // 顶点表
    rewind(stdin);
    for (i = 0; i < G->vexnum; i++) {
        // scanf("%c", &G->adjlist[i].data);
        G->adjlist[i].data.info = getchar();
        G->adjlist[i].data.no = i;
        G->adjlist[i].firstarc = NULL;
        getchar();  // 冲掉空格
    }
    // fflush(stdin);
    return G;
}
uint8_t Locate_vex(Graph* G, char Data) {
    int i;
    for (i = 0; i < G->vexnum; i++)
        if (G->adjlist[i].data.info == Data) {
            return i;
        }
    return ERR;
}
uint8_t ALG_Ins(Graph* G) {  // 边表
    uint8_t i, j, k, w;
    char v1, v2;
    ArcNode* e;
    printf("依次输入两个顶点和权值\n");
    for (k = 0; k < G->arcnum; k++) {
        rewind(stdin);
        scanf("%c %c %d", &v1, &v2, &w);  // 顶点,权值
        // getchar();
        i = Locate_vex(G, v1);
        j = Locate_vex(G, v2);
        if (i == ERR || j == ERR) {
            continue;  // 不存在
        }
        e = (ArcNode*)malloc(sizeof(ArcNode));
        e->adjvex = j;
        e->weight = w;
        e->next = G->adjlist[i].firstarc;
        G->adjlist[i].firstarc = e;
    }
}
uint8_t ALG_Del(Graph* G) {  // 返回权值
    uint8_t i, j, w;
    char v1, v2;
    ArcNode *p, *q;
    printf("输入顶点 ");
    rewind(stdin);
    scanf("%c %c", &v1, &v2);
    i = Locate_vex(G, v1);
    j = Locate_vex(G, v2);
    if (i == ERR || j == ERR) {
        return ERR;
    }
    p = G->adjlist[i].firstarc;
    if (p == NULL) {
        printf("该顶点无指向其他顶点的指针\n");
        return ERR;
    }
    q = p;
    while (q->adjvex != j) {
        p = q;
        q = p->next;
        if (q == NULL) {
            printf("%c->%c无边\n", v1, v2);
            return ERR;
        }
    }
    if (q == p) {  // 第一个指向的就是
        G->adjlist[i].firstarc = p->next;
        w = p->weight;
        free(p);
    } else {
        p->next = NULL;
        w = q->weight;
        free(q);
    }
    G->arcnum--;
    return w;
}

void DFS(Graph* G, uint8_t i) {
    ArcNode* e;
    visited[i] = 1;
    e = G->adjlist[i].firstarc;
    printf("%c ", G->adjlist[i].data.info);
    while (e) {
        if (visited[e->adjvex] == 0) {
            DFS(G, e->adjvex);
        }
        e = e->next;
    }
}
void ALG_DFS_Trav(Graph* G) {
    uint8_t i;
    for (i = 0; i < G->vexnum; i++) {
        visited[i] = 0;
    }
    for (i = 0; i < G->vexnum; i++) {
        if (visited[i] == 0) {
            DFS(G, i);
        }
    }
    printf("\n");
}
void ALG_BFS_Trav(Graph* G) {
    uint8_t i, j;
    ArcNode* e;
    Queue* Q;
    Q = Init_Queue();

    for (i = 0; i < G->vexnum; i++) {
        visited[i] = 0;
    }
    for (i = 0; i < G->vexnum; i++) {
        if (visited[i] == 0) {
            visited[i] = 1;
            printf("%c ", G->adjlist[i].data.info);
            En_Queue(Q, i);
            while (Q->Len != 0) {
                i = Q->Head->Data;
                De_Queue(Q);
                e = G->adjlist[i].firstarc;
                while (e) {
                    if (visited[e->adjvex] == 0) {
                        visited[e->adjvex] = 1;
                        printf("%c ", G->adjlist[e->adjvex].data.info);
                        De_Queue(Q);
                    }
                    e = e->next;
                }
            }
        }
    }
    printf("\n");
}

 

串：

#include <stdio.h>
#include <stdlib.h>  //中含字符串函数
#include <string.h>
void qk(char* src) {     // 清空串
    char p[10] = {'0'};  //{'0'}全赋零
    src = p;             //*p与数组等价
    printf("%s", src);   // 可直接输出
}
void lj(char* src, char* dest) {  // 串的连接
    char t[20];                   // 此串应该大
    int i;
    for (i = 0; src[i] != '\0'; i++) {
        // 注：'\0'为结束标记，即null（在stdio.h中）；'0'字符为48；
        // （空格）assic码值为32
        t[i] = src[i];
    }
    int j;
    for (j = 0; dest[j] != '\0'; j++) {
        t[i + j] = dest[j];
    }
    printf("%s", t);
}  // 两串放入一个新串
void chuan(int i, int m, char* src) {  // 返回主串中第i个位置开始的m个字符
    int j;
    char t[10];
    int k = 0;
    for (j = i - 1; j != i - 1 + m; j++) {  // 注：位置从1始，后m个数加m
        t[k] = src[j];                      // 放入新串
        k++;
    }
    printf("%s", t);
}
int Kmp(char* t, char* p, int* next) {
    int i = 0, j = 0;
    while (p[i] != 0 && t[j] != 0) {
        if (p[i] == t[j]) {
            i++;
            j++;
        } else if (next[i] >= 0) {
            i = next[i];
        } else {
            i = 0;
            j++;
        }
    }
    if (p[i] == 0)
        return j - i;  // found
    else
        return -1;  // not found
}
void KmpNext(char* p, int* next) {
    next[0] = -1;
    int k = -1;
    for (int i = 1; p[i - 1] != 0; i++) {
        while (k >= 0 && p[k] != p[i - 1]) {
            k = next[k];
            k = k + 1;
            if (p[i] == p[k]) {
                next[i] = next[k];
            } else {
                next[i = k];
            }
        }
    }
}
int pip(char* t, char* p) {  // 朴素模式匹配，后字符为模式串
    int i = 0;
    int j = 0;
    while (p[i] != '\0') {
        if (p[i] != t[j]) {
            j = j - i + 1;  // 注：回溯并后移一
            i = 0;          // 不等时回溯
        }
        if (t[j] == '\0')
            return -1;  // 不等出口
        if (p[i] == t[j]) {
            i++;
            j++;
        }  // 等时均++
        if (p[i] == t[j] && p[++i] == '\0') {
            return j - i + 1;  // 等出口
        }
    }
}
int main() {
    char src[10];
    char dest[10];
    int len;
    scanf("%s", dest);                // 注：可直接输入不加&
    strcpy(src, dest);                // 注:后赋予前
    char s[10] = "jfksjfk";           // 主串
    printf("%d\n", strcmp(dest, s));  // 比较函数
    /*如果返回值<0，则表示 str1 小于 str2。
    如果返回值> 0，则表示 str2 小于 str1。
    如果返回值 = 0，则表示 str1 等于 str2。*/

    len = strlen(src);  // 字符串长度
    printf("%d\n", len);
    printf("%s", src);
    int i;
    scanf("%d", &i);
    if (i == 1)
        qk(src);
    if (i == 2)
        lj(src, dest);
    if (i == 3) {
        int j, m;
        scanf("%d %d", &j, &m);
        chuan(j, m, src);
    }
    if (i == 4) {
        int e;
        e = pip(s, src);
        printf("%d", e);
    }
    if (i == 5) {
        int e;
        int m = 0;
        while (src[m] != 0)
            m++;
        int* next = (int*)malloc((m + 1) * sizeof(int));
        KmpNext(src, next);
        e = Kmp(s, src, next);
        printf("%d", e);
    }
    return 0;
}