Day24 目录遍历、双向链表、栈

day24 目录遍历、双向链表、栈


显示指定目录下的所有 .h 文件

功能描述

遍历指定目录(递归进入子目录),查找所有以 .h 为后缀的头文件,将其完整路径(路径 + 文件名)存储到双向链表中,并正向或反向打印输出。

核心技术点
  • 使用 opendir / readdir / closedir 进行目录遍历
  • 使用 DT_DIR 判断是否为目录,实现递归
  • 使用 sprintf 拼接路径字符串
  • 使用 strcmp 判断文件后缀是否为 .h
  • 使用双向链表动态存储匹配的文件路径

双向链表结构定义(DouLink.h
c 复制代码
#ifndef _DOULINK_H_
#define _DOULINK_H_

// 定义通用数据类型,用于存储文件路径
typedef struct person {
    char path[512];           // 存储文件的完整路径(含目录)
} DATATYPE;

// 双向链表节点
typedef struct dou_node {
    DATATYPE data;            // 数据域
    struct dou_node *prev;    // 指向前一个节点
    struct dou_node *next;    // 指向后一个节点
} DouLinkNode;

// 双向链表管理结构
typedef struct list {
    DouLinkNode *head;        // 指向链表头节点
    int clen;                 // 当前链表长度
} DouLinkList;

// 遍历方向枚举
typedef enum {
    DIR_FORWARD,              // 正向遍历
    DIR_BACKWARD              // 反向遍历
} DIRECT;

// 函数指针类型,用于查找、删除等操作
typedef int (*PFUN)(DATATYPE* data, void* arg);

// 函数声明
DouLinkList *CreateDouLinkList();
int InsertHeadDouLinkList(DouLinkList *dl, DATATYPE *data);
int InsertTailDouLinkList(DouLinkList *dl, DATATYPE *data);
int InsertPosDouLinkList(DouLinkList *dl, DATATYPE *data, int pos);
DouLinkNode *FindDouLinkList(DouLinkList *dl, PFUN fun, void* arg);
int ModifyDouLinkList(DouLinkList *dl, char *name, DATATYPE *newdata);
int DeleteDouLinkList(DouLinkList *dl, char *name);
int GetSizeDouLinkList(DouLinkList *dl);
int IsEmptyDouLinkList(DouLinkList *dl);
int DestroyDouLinkList(DouLinkList *dl);
int ShowDouLinkList(DouLinkList *dl, DIRECT direct);

#endif // _DOULINK_H_

说明 :该头文件定义了通用的双向链表结构,适用于多种数据类型。当前用于存储 .h 文件路径。


双向链表实现(DouLink.c
c 复制代码
#include "DouLink.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 创建空双向链表
DouLinkList *CreateDouLinkList() {
    DouLinkList *dl = malloc(sizeof(DouLinkList));
    if (NULL == dl) {
        perror("CreateDouLinkList malloc");
        return NULL;
    }
    dl->head = NULL;
    dl->clen = 0;
    return dl;
}

// 头插法插入节点
int InsertHeadDouLinkList(DouLinkList *dl, DATATYPE *data) {
    DouLinkNode *newnode = malloc(sizeof(DouLinkNode));
    if (NULL == newnode) {
        perror("InsertHeadDouLinkList malloc");
        return 1;
    }
    memcpy(&newnode->data, data, sizeof(DATATYPE));
    newnode->next = NULL;
    newnode->prev = NULL;

    if (IsEmptyDouLinkList(dl)) {
        dl->head = newnode;
    } else {
        newnode->next = dl->head;
        dl->head->prev = newnode;
        dl->head = newnode;
    }
    dl->clen++;
    return 0;
}

// 正向或反向打印链表
int ShowDouLinkList(DouLinkList *dl, DIRECT direct) {
    DouLinkNode *tmp = dl->head;
    if (DIR_FORWARD == direct) {
        while (tmp) {
            printf("%s\n", tmp->data.path);  // 输出文件路径
            tmp = tmp->next;
        }
    } else {
        // 找到最后一个节点
        while (tmp && tmp->next) {
            tmp = tmp->next;
        }
        // 从尾向前遍历
        while (tmp) {
            printf("%s\n", tmp->data.path);
            tmp = tmp->prev;
        }
    }
    return 0;
}

// 判断链表是否为空
int IsEmptyDouLinkList(DouLinkList *dl) {
    return 0 == dl->clen;
}

// 尾插法插入节点
int InsertTailDouLinkList(DouLinkList *dl, DATATYPE *data) {
    if (IsEmptyDouLinkList(dl)) {
        return InsertHeadDouLinkList(dl, data);
    } else {
        DouLinkNode *newnode = malloc(sizeof(DouLinkNode));
        if (NULL == newnode) {
            perror("InsertTailDouLinkList malloc");
            return 1;
        }
        memcpy(&newnode->data, data, sizeof(DATATYPE));
        newnode->next = NULL;
        newnode->prev = NULL;

        DouLinkNode *tmp = dl->head;
        while (tmp->next) {
            tmp = tmp->next;
        }
        newnode->prev = tmp;
        tmp->next = newnode;
    }
    dl->clen++;
    return 0;
}

// 在指定位置插入节点
int InsertPosDouLinkList(DouLinkList *dl, DATATYPE *data, int pos) {
    int size = GetSizeDouLinkList(dl);
    if (pos < 0 || pos > size) {
        printf("InsertPosDouLinkList pos error\n");
        return 1;
    }
    if (0 == pos) {
        return InsertHeadDouLinkList(dl, data);
    } else if (size == pos) {
        return InsertTailDouLinkList(dl, data);
    } else {
        DouLinkNode *newnode = malloc(sizeof(DouLinkNode));
        if (NULL == newnode) {
            perror("InsertPosDouLinkList malloc");
            return 1;
        }
        memcpy(&newnode->data, data, sizeof(DATATYPE));
        newnode->next = NULL;
        newnode->prev = NULL;

        DouLinkNode *tmp = dl->head;
        while (pos--) {
            tmp = tmp->next;
        }
        newnode->next = tmp;
        newnode->prev = tmp->prev;
        tmp->prev = newnode;
        newnode->prev->next = newnode;
        dl->clen++;
    }
    return 0;
}

// 通用查找函数:通过函数指针匹配数据
DouLinkNode *FindDouLinkList(DouLinkList *dl, PFUN fun, void* arg) {
    DouLinkNode* tmp = dl->head;
    while (tmp) {
        if (fun(&tmp->data, arg)) {
            return tmp;
        }
        tmp = tmp->next;
    }
    return NULL;
}

// 获取链表长度
int GetSizeDouLinkList(DouLinkList *dl) {
    return dl->clen;
}

// 销毁链表(释放所有节点和链表结构)
int DestroyDouLinkList(DouLinkList *dl) {
    DouLinkNode *tmp = NULL;
    while (dl->head) {
        tmp = dl->head;
        dl->head = dl->head->next;
        free(tmp);
    }
    free(dl);
    return 0;
}

理想运行结果

  • CreateDouLinkList() 返回一个空链表指针,head=NULL, clen=0
  • 插入操作后链表长度递增,ShowDouLinkList 可按正/反顺序输出路径
  • DestroyDouLinkList 释放所有内存,无泄漏

目录遍历与头文件查找(main.c
c 复制代码
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "DouLink.h"

// 指定起始路径(可修改)
char path[] = "/home/linux/20250818cd";

// 判断文件是否为 .h 后缀
int is_headfile(char* path) {
    if (strlen(path) < 3) return 0;
    char* tmp = &path[strlen(path) - 2];  // 取最后两个字符前的位置
    if (0 == strcmp(tmp, ".h")) {
        return 1;
    }
    return 0;
}

// 递归遍历目录,将 .h 文件路径插入链表
int do_ls(char* path, DouLinkList* dl) {
    DIR* dir = opendir(path);
    if (NULL == dir) {
        perror("opendir");
        return 1;
    }

    struct dirent* info;
    while ((info = readdir(dir)) != NULL) {
        char newpath[512] = {0};
        sprintf(newpath, "%s/%s", path, info->d_name);  // 拼接完整路径

        if (info->d_type == DT_DIR) {
            // 忽略 . 和 ..
            if (strcmp(info->d_name, ".") == 0 || strcmp(info->d_name, "..") == 0) {
                continue;
            }
            // 递归进入子目录
            do_ls(newpath, dl);
        } else {
            // 非目录,检查是否为 .h 文件
            DATATYPE data = {0};
            if (is_headfile(newpath)) {
                strcpy(data.path, newpath);
                InsertHeadDouLinkList(dl, &data);  // 头插存储
            }
        }
    }
    closedir(dir);
    return 0;
}

// 主函数:创建链表、遍历目录、打印结果
int main(int argc, char** argv) {
    DouLinkList* dl = CreateDouLinkList();
    do_ls("/home/linux", dl);  // 从 /home/linux 开始递归查找

    printf("=== 所有 .h 文件路径(正向输出)===\n");
    ShowDouLinkList(dl, DIR_FORWARD);

    DestroyDouLinkList(dl);
    return 0;
}

理想运行结果示例

复制代码
=== 所有 .h 文件路径(正向输出)===
/home/linux/20250818cd/test.h
/home/linux/20250818cd/include/utils.h
/home/linux/20250818cd/module/config.h
  • 成功递归进入所有子目录
  • 正确识别 .h 文件并存储完整路径
  • 输出顺序取决于插入方式(头插 → 逆序)

双向链表(通用版)

功能说明

该双向链表支持插入、删除、查找、修改、遍历等操作,适用于存储结构化数据(如学生信息)。

数据结构定义(DouLink.h
c 复制代码
#ifndef _DOULINK_H_
#define _DOULINK_H_

typedef struct person {
    char name[32];
    char sex;
    int age;
    int score;
} DATATYPE;

typedef struct dou_node {
    DATATYPE data;
    struct dou_node *prev;
    struct dou_node *next;
} DouLinkNode;

typedef struct list {
    DouLinkNode *head;
    int clen;
} DouLinkList;

typedef enum {
    DIR_FORWARD,
    DIR_BACKWARD
} DIRECT;

typedef int (*PFUN)(DATATYPE* data, void* arg);

// 函数声明(略去重复部分)
DouLinkList *CreateDouLinkList();
int InsertHeadDouLinkList(DouLinkList *dl, DATATYPE *data);
int InsertTailDouLinkList(DouLinkList *dl, DATATYPE *data);
int InsertPosDouLinkList(DouLinkList *dl, DATATYPE *data, int pos);
DouLinkNode *FindDouLinkList(DouLinkList *dl, PFUN fun, void* arg);
int ModifyDouLinkList(DouLinkList *dl, PFUN fun, void* arg, DATATYPE *newdata);
int DeleteDouLinkList(DouLinkList *dl, PFUN fun, void* arg);
int GetSizeDouLinkList(DouLinkList *dl);
int IsEmptyDouLinkList(DouLinkList *dl);
int DestroyDouLinkList(DouLinkList *dl);
int ShowDouLinkList(DouLinkList *dl, DIRECT direct);

#endif

说明 :此版本 DATATYPE 包含姓名、性别、年龄、成绩,适用于人员管理。


链表操作实现(DouLink.c
  • CreateDouLinkListInsertHead/InsertTail/InsertPosShowDouLinkListIsEmptyGetSize 实现同上(略)
  • 新增 ModifyDouLinkListDeleteDouLinkListDestroyDouLinkList
c 复制代码
// 根据条件修改节点数据
int ModifyDouLinkList(DouLinkList *dl, PFUN fun, void *arg, DATATYPE *newdata) {
    DouLinkNode *tmp = FindDouLinkList(dl, fun, arg);
    if (NULL == tmp) {
        printf("ModifyDouLinkList failure...\n");
        return 1;
    }
    memcpy(&tmp->data, newdata, sizeof(DATATYPE));
    return 0;
}

// 根据条件删除节点
int DeleteDouLinkList(DouLinkList *dl, PFUN fun, void *arg) {
    DouLinkNode *tmp = FindDouLinkList(dl, fun, arg);
    if (NULL == tmp) {
        printf("del failure...\n");
        return 1;
    }

    if (tmp == dl->head) {
        dl->head = dl->head->next;
        if (dl->head) dl->head->prev = NULL;
    } else {
        if (tmp->next) tmp->next->prev = tmp->prev;
        tmp->prev->next = tmp->next;
    }
    free(tmp);
    dl->clen--;
    return 0;
}

// 销毁整个链表
int DestroyDouLinkList(DouLinkList *dl) {
    DouLinkNode *tmp;
    while (dl->head) {
        tmp = dl->head;
        dl->head = dl->head->next;
        free(tmp);
    }
    free(dl);
    return 0;
}

测试程序(test.c
c 复制代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "DouLink.h"

// 按姓名查找
int findperbyname(DATATYPE* data, void* arg) {
    return 0 == strcmp(data->name, (char*)arg);
}

// 按年龄查找
int findperbyage(DATATYPE* data, void* arg) {
    return data->age == *(int*)arg;
}

int main(int argc, char** argv) {
    DouLinkList* dl = CreateDouLinkList();
    DATATYPE data[] = {
        {"zhangsan", 'm', 20, 80},
        {"lisi", 'f', 23, 84},
        {"wangmaizi", 'f', 32, 90},
        {"guanerge", 'm', 50, 91},
        {"liubei", 'm', 51, 92},
        {"zhangfei", 'm', 50, 80},
    };

    InsertHeadDouLinkList(dl, &data[0]);
    InsertHeadDouLinkList(dl, &data[1]);
    InsertHeadDouLinkList(dl, &data[2]);

    printf("------------正向输出--------------------\n");
    ShowDouLinkList(dl, DIR_FORWARD);
    printf("------------反向输出--------------------\n");
    ShowDouLinkList(dl, DIR_BACKWARD);

    InsertTailDouLinkList(dl, &data[3]);
    printf("------------尾插后--------------------\n");
    ShowDouLinkList(dl, DIR_FORWARD);

    InsertPosDouLinkList(dl, &data[4], 2);
    printf("------------位置插入后--------------------\n");
    ShowDouLinkList(dl, DIR_FORWARD);

    int age = 50;
    DouLinkNode* tmp = FindDouLinkList(dl, findperbyage, &age);
    if (tmp) {
        printf("找到年龄为50的人: %s, 成绩: %d\n", tmp->data.name, tmp->data.score);
    }

    ModifyDouLinkList(dl, findperbyname, "lisi", &data[5]);
    printf("------------修改后--------------------\n");
    ShowDouLinkList(dl, DIR_BACKWARD);

    DeleteDouLinkList(dl, findperbyname, "liubei");
    printf("------------删除后--------------------\n");
    ShowDouLinkList(dl, DIR_BACKWARD);

    DestroyDouLinkList(dl);
    return 0;
}

理想运行结果

  • 正确插入、查找、修改、删除
  • 输出格式:name:xxx sex:x age:xx score:xx
  • 修改后 lisi 变为 zhangfeiliubei 被删除

顺序表与链表对比

对比项 顺序表 链表
存储方式 连续内存空间 物理上不连续,逻辑上连续
查找性能 O(1) ------ 支持随机访问 O(n) ------ 需遍历
插入/删除 O(n) ------ 需移动元素 O(1) ------ 只需修改指针(已知位置)
空间分配 静态/固定大小,易浪费或溢出 动态分配,灵活,无空间浪费

循环链表

  • 将单链表最后一个节点的 next 指针指向头节点第一个有效节点,形成环状结构。
  • 空表判断:head == NULL
  • 非空表遍历条件:p->next != head(代替 p->next != NULL
  • 常用于约瑟夫环、循环任务调度等场景。

双向链表(结构简写版)

c 复制代码
typedef struct DulNode {
    ElemType data;               // 数据域
    struct DulNode *pri;         // 指向前驱
    struct DulNode *next;        // 指向后继
} DulNode, *DuLinkList;

✅ 注意:原始代码中 sturct 拼写错误,已修正为 struct


栈(Stack)

定义

限定仅在表尾 进行插入和删除操作的线性表,遵循 "先进后出"(LIFO) 原则。

核心概念
  • 栈顶:允许操作的一端(插入/删除)
  • 栈底:不允许操作的一端
  • 基本操作
    • 入栈(Push)
    • 出栈(Pop)
    • 获取栈顶元素(GetTop)
分类
  • 顺序栈(数组实现)
  • 链式栈(链表实现)
链式栈结构定义(LinkStack.h
c 复制代码
#ifndef _LINKSTACK_H_
#define _LINKSTACK_H_

typedef struct {
    char name[50];
    char sex;
    int age;
    int score;
} DATATYPE;

typedef struct _linkstacknode {
    DATATYPE data;
    struct _linkstacknode *next;
} LinkStackNode;

typedef struct {
    LinkStackNode* top;   // 栈顶指针
    int clen;             // 元素个数
} LinkStack;

// 函数声明
LinkStack* CreateLinkStack();
int PushLinkStack(LinkStack* ls, DATATYPE* data);
int PopLinkStack(LinkStack* ls);
DATATYPE* GetTopLinkStack(LinkStack* ls);
int IsEmptyLinkStack(LinkStack* ls);
int GetSizeLinkStack(LinkStack* ls);
int DestroyLinkStack(LinkStack* ls);

#endif

链式栈实现(LinkStack.c
c 复制代码
#include "LinkStack.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

LinkStack* CreateLinkStack() {
    LinkStack* ls = malloc(sizeof(LinkStack));
    if (!ls) {
        perror("CreateLinkStack malloc error");
        return NULL;
    }
    ls->top = NULL;
    ls->clen = 0;
    return ls;
}

int PushLinkStack(LinkStack* ls, DATATYPE* data) {
    LinkStackNode* newnode = malloc(sizeof(LinkStackNode));
    if (!newnode) {
        perror("PushLinkStack malloc error");
        return 1;
    }
    memcpy(&newnode->data, data, sizeof(DATATYPE));
    newnode->next = ls->top;
    ls->top = newnode;
    ls->clen++;
    return 0;
}

int PopLinkStack(LinkStack* ls) {
    if (IsEmptyLinkStack(ls)) {
        printf("linkstack is empty\n");
        return 1;
    }
    LinkStackNode* tmp = ls->top;
    ls->top = ls->top->next;
    free(tmp);
    ls->clen--;
    return 0;
}

DATATYPE* GetTopLinkStack(LinkStack* ls) {
    if (IsEmptyLinkStack(ls)) return NULL;
    return &ls->top->data;
}

int IsEmptyLinkStack(LinkStack* ls) {
    return 0 == ls->clen;
}

int GetSizeLinkStack(LinkStack* ls) {
    return ls->clen;
}

int DestroyLinkStack(LinkStack* ls) {
    while (!IsEmptyLinkStack(ls)) {
        PopLinkStack(ls);
    }
    free(ls);
    return 0;
}

测试程序(test_stack.c
c 复制代码
#include <stdio.h>
#include "LinkStack.h"

int main() {
    LinkStack* ls = CreateLinkStack();
    DATATYPE data[] = {
        {"zhangsan", 'm', 20, 80},
        {"lisi", 'f', 23, 84},
        {"wangmaizi", 'f', 32, 90},
        {"guanerge", 'm', 50, 91},
        {"liubei", 'm', 51, 92}
    };

    for (int i = 0; i < 5; i++) {
        PushLinkStack(ls, &data[i]);
    }

    printf("出栈顺序(LIFO):\n");
    while (!IsEmptyLinkStack(ls)) {
        DATATYPE* tmp = GetTopLinkStack(ls);
        printf("name:%s score:%d\n", tmp->name, tmp->score);
        PopLinkStack(ls);
    }

    DestroyLinkStack(ls);
    return 0;
}

理想运行结果

复制代码
出栈顺序(LIFO):
name:liubei score:92
name:guanerge score:91
name:wangmaizi score:90
name:lisi score:84
name:zhangsan score:80

使用栈实现 C 源文件符号匹配

原理
  • 遇到 ([{ 入栈
  • 遇到 )]} 检查栈顶是否匹配,匹配则出栈,否则报错
  • 文件结束时栈应为空,否则有未闭合符号
实现代码(check_brackets.c
c 复制代码
#include <stdio.h>
#include <string.h>
#include "LinkStack.h"

// 记录符号位置的结构
typedef struct {
    char c;
    int row;
    int col;
} SymData;

int do_check(char* linebuf, LinkStack* ls, int num) {
    char* tmp = linebuf;
    SymData data = {0};
    SymData* top = NULL;
    int col = 1;

    while (*tmp) {
        switch (*tmp) {
            case '(':
            case '[':
            case '{':
                data.c = *tmp;
                data.row = num;
                data.col = col;
                PushLinkStack(ls, (DATATYPE*)&data);
                break;
            case ')':
                top = (SymData*)GetTopLinkStack(ls);
                if (!top || top->c != '(') {
                    printf("括号不匹配: ) at row %d col %d\n", num, col);
                    return 1;
                }
                PopLinkStack(ls);
                break;
            case ']':
                top = (SymData*)GetTopLinkStack(ls);
                if (!top || top->c != '[') {
                    printf("括号不匹配: ] at row %d col %d\n", num, col);
                    return 1;
                }
                PopLinkStack(ls);
                break;
            case '}':
                top = (SymData*)GetTopLinkStack(ls);
                if (!top || top->c != '{') {
                    printf("括号不匹配: } at row %d col %d\n", num, col);
                    return 1;
                }
                PopLinkStack(ls);
                break;
        }
        tmp++;
        col++;
    }
    return 0;
}

int main() {
    LinkStack* ls = CreateLinkStack();
    FILE* fp = fopen("/home/linux/2.c", "r");
    if (!fp) {
        printf("fopen error\n");
        return 1;
    }

    int num = 1;
    char buf[1024];
    while (fgets(buf, sizeof(buf), fp)) {
        if (do_check(buf, ls, num)) {
            fclose(fp);
            DestroyLinkStack(ls);
            return 1;
        }
        num++;
    }

    if (IsEmptyLinkStack(ls)) {
        printf("✅ 所有括号匹配成功!\n");
    } else {
        SymData* top = (SymData*)GetTopLinkStack(ls);
        printf("❌ 存在未闭合符号: %c at row %d col %d\n", top->c, top->row, top->col);
    }

    fclose(fp);
    DestroyLinkStack(ls);
    return 0;
}

理想运行结果

  • 若括号全部匹配:输出 ✅ 所有括号匹配成功!
  • 若有不匹配:输出具体错误位置
  • 支持跨行匹配

栈的核心要点总结

  • 本质:受限制的线性表,仅允许在一端进行操作
  • 操作特性:先进后出(LIFO)
  • 两端定义
    • 栈顶:可进行插入/删除
    • 栈底:固定,不可操作
  • 主要作用
    • 递归调用管理
    • 表达式求值
    • 回溯算法
    • 符号匹配检查
  • 基本操作
    • 入栈(Push)
    • 出栈(Pop)
    • 获取栈顶(GetTop)