双向循环链表实践---学生管理系统

最新推荐文章于 2023-02-14 11:23:40 发布
最新推荐文章于 2023-02-14 11:23:40 发布
阅读量1.6k 收藏 30
点赞数 5
分类专栏： 算法及其实践 文章标签： 双向循环链表 学生管理系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaocui92/article/details/79182211
版权

写在前面

在看Linux源码时，经常会涉及到驱动和设备的匹配，如果想弄清楚匹配过程，就要理解双向循环链表。
这篇文章是理解了Linux的list.h文件后自己的实现应用。

理论知识

这里写图片描述

实现步骤

链表的常用的节点操作如下：
增加、删除、查找

首先定义一个结构体，存放学生的信息

struct student {
    int number;
    char id[20];   //学号
    char name[20]; //姓名
    float score;   //成绩
    struct student *next;
    struct student *prev;
};
创建头节点
  1. 创建头指针
  2. 初始化头指针
    1. 分配内存
    2. 自己指向自己 
struct student *head = NULL;

/*create head node*/
void init(void)  
{
    printf("%s\n", __func__);
    head = (struct student *)malloc(sizeof(struct student));
    head->next = head;   
    head->prev = head;
}
增加节点
void add_student(void)
{
    /*增加一个学生的信息*/
    char new_id[20] = {0};
    char new_name[20] = {0};
    float new_score = 0.00;
    memset(new_id, 0, sizeof(new_id));
    memset(new_name, 0, sizeof(new_name));

    printf("%s\n", __func__);

    printf("enter the id:\n");
    scanf("%s", new_id);

    /*id是唯一的依据，所以要进行去重操作*/
    if(have_same_id(new_id)){
        printf("hava same id\n");
        goto have_same_id;
    }

    printf("enter the name:\n");
    scanf("%s", new_name);
    printf("enter the score:\n");
    scanf("%f", &new_score);

    /*增加新节点核心操作*/
    struct student * new_node = (struct student *)malloc(sizeof(struct student));
    struct student * last_node = head->prev;
    last_node->next = new_node;
    new_node->prev = last_node;
    head->prev = new_node;
    new_node->next = head;

    count++;
    /*节点信息填充*/
    new_node->number = count;
    memset(new_node->id, 0, sizeof(new_node->id));
    memset(new_node->name, 0, sizeof(new_node->name));
    strcpy(new_node->id, new_id);
    strcpy(new_node->name, new_name);
    new_node->score = new_score;

    printf("add student ok!\n");

    list_all_student();

have_same_id:
    return ;
}
#define HAVE_SAME_ID    1
#define NO_SAME_ID      0

int have_same_id(char *id)
{
    struct student *pos = NULL;
    for(pos = head->next; pos != head; pos = pos->next)
    {
        if(strcmp(pos->id, id) == 0){
            return HAVE_SAME_ID;
        }
    }
    return NO_SAME_ID;
}
删除节点
void delete_student()
{
    struct student * pos = NULL;
    char id[20];
    printf("%s\n", __func__);

    memset(id, 0, sizeof(id));
    /*以ID为唯一凭证*/
    printf("enter the id that you want delete:\n");
    scanf("%s", id);

    //删除节点核心实现
    for(pos = head->next; pos != head; pos = pos->next)
    {
        if(strcmp(pos->id, id) == 0){
            printf("delete\t%d\t%s\t\t\t%s\t\t\t%f\n", pos->number, pos->id, pos->name, pos->score);
            pos->prev->next = pos->next;
            pos->next->prev = pos->prev;
            free(pos);
            delete_student_fixed_count(); //删除节点后，修复节点中number标记
            return;
        }
    }

    printf("no the same id, pleace check it again\n");

}
void delete_student_fixed_count(void)
{
    struct student *pos = NULL; 
    int i = 0;
    count--;
    for(pos = head->next, i = 1; pos != head; pos = pos->next, i++)
    {
        pos->number = i;
    }
    i--;
    if(i != count){
        printf("i = %d\t, count = %d\n", i, count);
        printf("count error\n");
    }
    list_all_student();

}
查找节点

查找结点比较简单，根据一个值遍历所有节点即可
示例代码中，以学生ID为唯一参考

void search_student_score(void)
{
    struct student * pos = NULL;
    char id[20];
    printf("%s\n", __func__);

    memset(id, 0, sizeof(id));

    printf("enter the id that want to search:\n");
    scanf("%s", id);

    //核心代码
    for(pos = head->next; pos != head; pos = pos->next)
    {
        if(strcmp(pos->id, id) == 0){
            printf("find the id:\n");
            printf("\tid\t\t\tname\t\t\tsorce\n");
            printf("%d\t%s\t\t\t%s\t\t\t%f\n", pos->number, pos->id, pos->name, pos->score);
            return;
        }
    }
    printf("sorry, can not find the id info\n");

}
释放节点

由于内存空间是使用malloc进行分配的，所有要用free进行手动释放，释放某一个节点比较简单，释放所有节点相对复杂点，其实就是遍历所有节点，并一一删除。

释放一个节点
  1. 以ID为标记，找到要释放的节点
  2. 注意修改节点的next和prev节点
  3. 释放该节点的内存
void delete_student()
{
    struct student * pos = NULL;
    char id[20];
    printf("%s\n", __func__);

    memset(id, 0, sizeof(id));
    printf("enter the id that you want delete:\n");
    scanf("%s", id);

    //核心实现
    for(pos = head->next; pos != head; pos = pos->next)
    {
        if(strcmp(pos->id, id) == 0){
            printf("delete\t%d\t%s\t\t\t%s\t\t\t%f\n", pos->number, pos->id, pos->name, pos->score);
            pos->prev->next = pos->next;
            pos->next->prev = pos->prev;
            free(pos);
            delete_student_fixed_count();
            return;
        }
    }

    printf("no the same id, pleace check it again\n");

}
删除所有节点

结束程序时，要删除所有分配过的内存，防止内存泄漏
该操作就是遍历所有节点并释放内存

void free_all_memory()
{
    struct student * pos = head->next;
    printf("%s\n", __func__);
    for(; pos != head; )
    {
        head->next = pos->next;
        pos->next->prev = head;
        printf("\tdelete node->number = %d\n", pos->number);   //显示所有要删除的节点，防止有内存泄露
        free(pos);
        pos = head->next;
    }
    printf("\tdelete head node\n");
    free(head);
}
完整代码

此示例代码，已经实验过，无内存泄漏，所有功能实现。

/*************************
    双向循环链表练习
      学生管理系统
       2018.01.27
        cxiaolei
*************************/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define HAVE_SAME_ID    1
#define NO_SAME_ID      0

struct student {
    int number;
    char id[20];   //学号
    char name[20]; //姓名
    float score;//成绩
    struct student *next;
    struct student *prev;
};

int count = 0;

struct student *head = NULL;

/*create head node*/
void init(void)  
{
    printf("%s\n", __func__);
    head = (struct student *)malloc(sizeof(struct student));
    head->next = head;   
    head->prev = head;
}

void list_all_student(void)
{
    struct student *pos = NULL;
    printf("%s\n", __func__);
    printf("\n\n\n\tid\t\t\tname\t\t\tsorce\n");
    for(pos = head->next; pos != head; pos = pos->next)
    {
        printf("%d\t%s\t\t\t%s\t\t\t%f\n", pos->number, pos->id, pos->name, pos->score);
    }
    printf("\n\n\n%s : end\n", __func__);
}

int have_same_id(char *id)
{
    struct student *pos = NULL;
    for(pos = head->next; pos != head; pos = pos->next)
    {
        if(strcmp(pos->id, id) == 0){
            return HAVE_SAME_ID;
        }
    }
    return NO_SAME_ID;
}

void delete_student_fixed_count(void)
{
    struct student *pos = NULL; 
    int i = 0;
    count--;
    for(pos = head->next, i = 1; pos != head; pos = pos->next, i++)
    {
        pos->number = i;
    }
    i--;
    if(i != count){
        printf("i = %d\t, count = %d\n", i, count);
        printf("count error\n");
    }
    list_all_student();

}

void add_student(void)
{
    char new_id[20] = {0};
    char new_name[20] = {0};
    float new_score = 0.00;
    memset(new_id, 0, sizeof(new_id));
    memset(new_name, 0, sizeof(new_name));

    printf("%s\n", __func__);

    printf("enter the id:\n");
    scanf("%s", new_id);

    if(have_same_id(new_id)){
        printf("hava same id\n");
        goto have_same_id;
    }

    printf("enter the name:\n");
    scanf("%s", new_name);
    printf("enter the score:\n");
    scanf("%f", &new_score);

    struct student * new_node = (struct student *)malloc(sizeof(struct student));
    struct student * last_node = head->prev;
    last_node->next = new_node;
    new_node->prev = last_node;
    head->prev = new_node;
    new_node->next = head;

    count++;

    new_node->number = count;
    memset(new_node->id, 0, sizeof(new_node->id));
    memset(new_node->name, 0, sizeof(new_node->name));
    strcpy(new_node->id, new_id);
    strcpy(new_node->name, new_name);
    new_node->score = new_score;

    printf("add student ok!\n");

    list_all_student();

have_same_id:
    return ;
}

void delete_student()
{
    struct student * pos = NULL;
    char id[20];
    printf("%s\n", __func__);

    memset(id, 0, sizeof(id));
    printf("enter the id that you want delete:\n");
    scanf("%s", id);

    for(pos = head->next; pos != head; pos = pos->next)
    {
        if(strcmp(pos->id, id) == 0){
            printf("delete\t%d\t%s\t\t\t%s\t\t\t%f\n", pos->number, pos->id, pos->name, pos->score);
            pos->prev->next = pos->next;
            pos->next->prev = pos->prev;
            free(pos);
            delete_student_fixed_count();
            return;
        }
    }

    printf("no the same id, pleace check it again\n");

}

void search_student_score(void)
{
    struct student * pos = NULL;
    char id[20];
    printf("%s\n", __func__);

    memset(id, 0, sizeof(id));

    printf("enter the id that want to search:\n");
    scanf("%s", id);

    for(pos = head->next; pos != head; pos = pos->next)
    {
        if(strcmp(pos->id, id) == 0){
            printf("find the id:\n");
            printf("\tid\t\t\tname\t\t\tsorce\n");
            printf("%d\t%s\t\t\t%s\t\t\t%f\n", pos->number, pos->id, pos->name, pos->score);
            return;
        }
    }
    printf("sorry, can not find the id info\n");

}

void modify_student_score(void)
{
    struct student * pos = NULL;
    char id[20];
    float score = 0.00;
    printf("%s\n", __func__);

    memset(id, 0, sizeof(id));

    printf("enter the id that want to modify:\n");
    scanf("%s", id);
    printf("enter the score that want to modify:\n");
    scanf("%f", &score);

    for(pos = head->next; pos != head; pos = pos->next)
    {
        if(strcmp(pos->id, id) == 0){
            printf("find the id and modify the score:\n");
            pos->score = score;
            printf("\tid\t\t\tname\t\t\tsorce\n");
            printf("%d\t%s\t\t\t%s\t\t\t%f\n", pos->number, pos->id, pos->name, pos->score);
            return;
        }
    }
    printf("sorry, can not find the id info\n");
}

void free_all_memory()
{
    struct student * pos = head->next;
    struct student * pos_next = NULL;
    printf("%s\n", __func__);
    for(; pos != head; )
    {
        //pos_next = pos->next;
        head->next = pos->next;
        pos->next->prev = head;
        printf("\tdelete node->number = %d\n", pos->number);
        free(pos);
        pos = head->next;
    }
    printf("\tdelete head node\n");
    free(head);
}

int main(void)
{
    int user_select = 0;

    init();

    printf("简单的学生管理系统");
    while(1){
        printf("function select\n");
        printf("\t1. add a student info\n\t2. delete a student info\n\t3. search student score\n\t4. modify student score\n\t5. list all student\n\t0. quit the application\n");
        scanf("%d", &user_select);
        switch(user_select){
            case 0:{
                free_all_memory();
                printf("the application will quit\n");
                return 0;
            }           
            case 1:{
                add_student();
                break;
            }
            case 2:{
                delete_student();
                break;
            }       
            case 3:{
                search_student_score();
                break;
            }
            case 4:{
                modify_student_score();
                break;
            }
            case 5:{
                list_all_student();
                break;
            }
            default:{
                printf("enter error\n");
                free_all_memory();
                break;
            }
        }
    }
    return 0;
}
cxiaolei1992
关注
  • 5
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于双向循环链表实现的学生教务管理系统.rar
09-12
基于双向链表实现的教务管理系统 增删改查
C语言学生成绩管理系统——检查学号姓名，双向循环链表
chfens的博客
06-18 1671
检查学号和姓名格式、插入排序、保存本地磁盘，双向带头循环链表。
循环链表(单向+双向)及典型应用场景
cj1561435010的博客
02-23 5241
一、单向循环链表 1、单向循环链表明细        单向循环链表其实就是尾结点有指向头结点的指针，一般链表尾结点指向的都是空。        添加结点的时候尾部情况和普通情况一样，不需要特殊处理(因为尾部有指向头结点的指针)。头部添加结点的时候还需要对第一次...
头指针双向循环链表实现学生信息统计
PC0monkey的博客
09-17 137
头指针，头指针
链表实现学生信息存储（01）
xuezhe_____的博客
12-06 3614
#include<stdio.h> #include<stdlib.h> #define PT "学号：%ld 姓名：%-10s 性别：%c\n",p->num,p->name,p->sex #define N sizeof(struct student) struct student { long num; char name[11]; char ...
linux下内核链表实现学生信息管理系统
c_shell_python的博客
03-05 2682
内核链表 我们知道，内核链表是双向链表，在这里不详细介绍内核链表的概念，只列出demo并附上注释供需要的同学参考。 下面使用内核链表完成基本的增删改查，实现简易的学生信息管理系统，拥有保存信息到txt文本的功能，和从txt中读取信息的功能。（内核链表的头文件可以百度直接下载） #include"kernel_list.h" //内核链表的头，只需加入内核链表的c文件，一起编译即可...
基于双向循环链表实现的学生管理系统
weixin_43357542的博客
05-13 467
student.c文件如图所示 #include<stdio.h> #include<stdlib.h> #include<time.h> #include<string.h> #include"student.h" INT32 main(VOID) { CHAR chstuName[MAXNAMELENGTH]; NODE psthead = cr...
双向循环链表实习学生管理系统
九点就去睡
02-14 251
学生管理系统
双向循环链表实现—通讯录（学生管理系统，自行车管理系统，影院管理系统）—C语言课设（万能模板）—数据结构—用文件存储数据
普通大学生的博客
02-11 3191
双向循环链表实现，课设万能模板，通讯录，学生管理系统，自行车管理系统，影院管理系统......均可用
双向循环链表-仿学生管理系统【详尽注释】
04-09
双向循环链表-仿学生管理系统【详尽注释】 具备创建、添加、删除、查找、修改、排序、及输出！
数据结构双向链表学生成绩管理系统
08-26
利用数据结构构建双向链表实现了学生成绩管理，管理包括对学生成绩的相关操作，如双向查找，添加，删除，排序，输出等多种功能。
C语言实现 学生信息管理系统 双链表
08-20
STMS学生信息管理系统； 采用C语言、由双链表实现，有学生、老师、管理员三种角色登陆，每种角色权限功能不一样。
基于java的循环双链表
12-22
使用java语言编译循环双链表，有三个类，分别是一个接口类，一个循环双链表继承接口的实现类，一个循环双链表的测试类
用Java实现模拟双向循环链表LinkedList
02-28
这是自己写的一个Java实现模拟数据结构中的LinkedList。实现其简单的添加节点功能
C++ 双向链表实现学生管理系统
06-09
C++ 双向链表实现学生管理系统
双向循环链表实现学生分数管理系统
12-03
用c语言实现一个基本的学生分数管理系统希望对您有所帮助抛砖引玉
航班订票系统（单向，双向循环链表）
03-26
用单向链表存储航班信息，双向链表存储乘客信息，并可以订票，退票和查询的航班订票系统！
航班管理系统 单向顺序链表 双向非循环顺序链表
07-04
1.航班管理员可以——添加航班——查询航班信息——修改航班信息——查询乘客信息（管理员登陆口令：123456） 2.乘客可以——查询航班信息——订票——退票 3.航班链表为单向顺序链表，乘客链表为双向非循环顺序链表
学生管理系统——基于双向循环链表
weixin_34248023的博客
09-03 234
2019独角兽企业重金招聘Python工程师标准>>> ...
学生信息管理系统使用链表
最新发布
04-03
4. 灵活性高：链表可以根据实际需求选择单向链表、双向链表、循环链表等不同类型的链表。 在学生信息管理系统中，可以使用单向链表来存储学生信息。每个节点包含学生的信息和指向下一个节点的指针。可以通过遍历...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值