单向链表之嵌套结构体的练习

最新推荐文章于 2024-07-25 02:49:15 发布
最新推荐文章于 2024-07-25 02:49:15 发布
阅读量80 收藏 1
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43921012/article/details/129908675
版权

现有学生的信息需要存储，学生信息包括：姓名、年龄、分数，利用单向表实现以下功能：

  1. 创建头结点

  2. 创建普通结点

  3. 单链表头插

  4. 单链表尾插

  5. 单链表的遍历

  6. 单链表的头删

  7. 单链表尾删

  8. 单链表按位置插入

  9. 单链表按位置删除

  10. 单链表按位置修改

  11. 单链表按位置查找

  12. 单链表按元素查找

  13. 单链表按元素修改

  14. 单链表按元素删除

  15. 单链表逆置

  16. 按成绩冒泡排序

  17. 单链表的释放

main.c

#include "main.h"

int main(int argc, char const *argv[])
{
    int n;
    linklist L = Create_Head();
    printf("请输入学生个数：");
    scanf("%d",&n);
    datatype e;
    printf("\n<-------------------------学生信息录入------------------------->\n\n");
    
#if 0

    for (size_t i = 0; i < n; i++)
    {
        printf("请输入第%ld名学生的姓名：",i+1);
        scanf("%s",e.name);
        printf("请输入第%ld名学生的年龄：",i+1);
        scanf("%d",&e.age);
        printf("请输入第%ld名学生的分数：",i+1);
        scanf("%lf",&e.score);
        Insert_Head(L,e);
        printf("\n");
    }

#else

    for (size_t i = 0; i < n; i++)
    {
        printf("请输入第%ld名学生的姓名：",i+1);
        scanf("%s",e.name);
        printf("请输入第%ld名学生的年龄：",i+1);
        scanf("%d",&e.age);
        printf("请输入第%ld名学生的分数：",i+1);
        scanf("%lf",&e.score);
        Insert_Rear(L,e);
        printf("\n");
    }

#endif

    OutputList(L);

    //链表头删
    printf("\n<-------------------------学生信息头删------------------------->\n\n");
    Delete_Head(L);
    OutputList(L);

    //链表尾删
    printf("\n<-------------------------学生信息尾删------------------------->\n\n");
    Delete_Rear(L);
    OutputList(L);

    //单链表按位置插入
    printf("\n<-------------------------学生信息按位置插入------------------------->\n\n");
    int pos;
    printf("请输入插入的位置：");
    scanf("%d",&pos);
    if(pos>=1 && pos<=L->len+1)
    {
        printf("请输入插入的学生的姓名：");
        scanf("%s",e.name);
        printf("请输入插入的学生的年龄：");
        scanf("%d",&e.age);
        printf("请输入插入的学生的分数：");
        scanf("%lf",&e.score);
        Insert_Position(L,pos,e);
        OutputList(L);
    }
    else
    {
        printf("\n插入位置不合法，操作失败!\n\n");
    }

    //单链表按位置删除
    printf("\n<-------------------------学生信息按位置删除------------------------->\n\n");
    printf("请输入删除的位置：");
    scanf("%d",&pos);
    Delete_Position(L,pos);
    OutputList(L);

    //单链表按位置修改
    printf("\n<-------------------------学生信息按位置修改------------------------->\n\n");
    printf("请输入修改的位置：");
    scanf("%d",&pos);
    if(pos>=1 && pos<=L->len)
    {
        printf("请输入修改后的学生的姓名：");
        scanf("%s",e.name);
        printf("请输入修改后的学生的年龄：");
        scanf("%d",&e.age);
        printf("请输入修改后的学生的分数：");
        scanf("%lf",&e.score);
        Updata_Position(L,pos,e);
        OutputList(L);
    }
    else
    {
        printf("\n修改位置不合法，操作失败!\n\n");
    }

    //单链表按位置查找
    printf("\n<-------------------------学生信息按位置查找------------------------->\n\n");
    printf("请输入查找的位置：");
    scanf("%d",&pos);
    Search_Position(L,pos);

    //单链表按元素查找
    printf("\n<-------------------------学生信息按元素查找------------------------->\n\n");
    printf("请输入查找的学生的姓名：");
    scanf("%s",e.name);
    printf("请输入查找的学生的年龄：");
    scanf("%d",&e.age);
    printf("请输入查找的学生的分数：");
    scanf("%lf",&e.score);
    printf("\n您所查询的学生在位置：%d\n\n",Search_Data(L,e));
    OutputList(L);

    //单链表按元素修改
    datatype key;
    printf("\n<-------------------------学生信息按元素修改------------------------->\n\n");
    printf("请输入修改前的学生的姓名：");
    scanf("%s",key.name);
    printf("请输入修改前的学生的年龄：");
    scanf("%d",&key.age);
    printf("请输入修改前的学生的分数：");
    scanf("%lf",&key.score);
    printf("\n\n");
    printf("请输入修改后的学生的姓名：");
    scanf("%s",e.name);
    printf("请输入修改后的学生的年龄：");
    scanf("%d",&e.age);
    printf("请输入修改后的学生的分数：");
    scanf("%lf",&e.score);
    Updata_Data(L,key,e);
    OutputList(L);

    //单链表按元素删除
    printf("\n<-------------------------学生信息按元素删除------------------------->\n\n");
    printf("请输入删除的学生的姓名：");
    scanf("%s",e.name);
    printf("请输入删除的学生的年龄：");
    scanf("%d",&e.age);
    printf("请输入删除的学生的分数：");
    scanf("%lf",&e.score);
    Delete_Data(L,e);
    OutputList(L);

    //单链表逆置
    printf("\n<-------------------------学生信息逆置------------------------->\n\n");
    printf("逆置前的学生信息如下所示：\n");
    OutputList(L);
    printf("逆置后的学生信息如下所示：\n");
    Inversion_Link(L);
    OutputList(L);
  
    //冒泡排序
    printf("\n<-------------------------学生信息按成绩排序------------------------->\n\n");
    printf("排序前的学生信息如下所示：\n");
    OutputList(L);
    printf("排序后的学生信息如下所示：\n");
    BubbleSort(L);
    OutputList(L);

    //链表空间释放
    L = free_space(L);

    return 0;
}

main.h

#ifndef __MAIN_H
#define __MAIN_H

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

//学生信息结构体
typedef struct
{
    char name[20];  //学生信息
    int age;    //学生年龄
    double score;   //学生分数
}Student;

typedef Student datatype;

typedef struct Node
{
    //数据域
    union
    {
        int len;    //头结点数据域
        datatype data;
    };
    //指针域
    struct Node *next;  //指向下一个结点   
}*linklist;

linklist Create_Head(); //创建头结点
linklist Create_Node(); //创建普通结点
int Insert_Head(linklist L,datatype e); //单链表头插
int Insert_Rear(linklist L,datatype e); //单链表尾插
void OutputList(linklist L);    //单链表的遍历
int Delete_Head(linklist L);    //单链表的头删
int Delete_Rear(linklist L);    //单链表尾删
int Insert_Position(linklist L,int pos,datatype e); //单链表按位置插入
int Delete_Position(linklist L,int pos);    //单链表按位置删除
int Updata_Position(linklist L,int pos,datatype e); //单链表按位置修改
int Search_Position(linklist L,int pos);    //单链表按位置查找
int Search_Data(linklist L,datatype e);     //单链表按元素查找
int Updata_Data(linklist L,datatype key,datatype e);    //单链表按元素修改
int Delete_Data(linklist L,datatype e); //单链表按元素删除
int Inversion_Link(linklist L); //单链表逆置
void BubbleSort(linklist L);    //冒泡排序
linklist free_space(linklist L);    //单链表的释放


#endif // !__MAIN_H

linklist.c

#include "main.h"

/**
 * @brief   创建头结点
 * 
 * @return linklist 
 */
linklist Create_Head()
{
    linklist L = (linklist)malloc(sizeof(struct Node));
    if (L == NULL)
        return NULL;
    //数据域
    L->len = 0;
    //指针域
    L->next = NULL;
    return L;
}

/**
 * @brief   创建普通结点
 * 
 * @return linklist 
 */
linklist Create_Node()
{
    linklist p = (linklist)malloc(sizeof(struct Node));
    if (p == NULL)
        return NULL;
    //数据域
    strcpy(p->data.name,"\0");
    p->data.age = 0;
    p->data.score = 0;
    //指针域
    p->next = NULL;
    return p;
}

/**
 * @brief       单链表头插
 * 
 * @param L     单链表
 * @param e     插入的学生信息
 * @return int  成功返回0,失败返回-1
 */
int Insert_Head(linklist L,datatype e)
{
    if (L == NULL)
    {
        printf("\n链表不存在，数据头插失败！\n\n");
        return -1;
    }
    linklist p = Create_Node();
    if (p == NULL)
        return -1;
    //数据域
    p->data = e;
    //指针域
    p->next = L->next;
    L->next = p;
    L->len++;
    return 0;
}

/**
 * @brief       单链表尾插
 * 
 * @param L     
 * @param e     学生信息
 * @return int  成功返回0,失败返回-1
 */
int Insert_Rear(linklist L,datatype e)
{
    if (L == NULL)
    {
        printf("\n链表不存在，数据尾插失败！\n\n");
        return -1;
    }

    linklist p = Create_Node();
    if (p == NULL)
        return -1;
    
    linklist q = L;
    for (size_t i = 1; i <= L->len; i++)
    {
        q = q->next;        
    }
    //指针域
    p->next = q->next;
    q->next = p;
    //数据域
    p->data = e;
    L->len++;
    return 0;

}


/**
 * @brief   链表遍历输出
 * 
 * @param L 
 */
void OutputList(linklist L)
{
    if (L == NULL || L->len == 0)
    {
        printf("\n数据元素不存在，遍历失败！\n\n");
        return;
    }
    linklist p = L;
    for (size_t i = 1; i <= L->len; i++)
    {
        p = p->next;
        printf("\n姓名\t\t年龄\t\t分数\n");
        printf("\n%s\t\t%d\t\t%.1lf\n",p->data.name,p->data.age,p->data.score);
    }
}

/**
 * @brief       单链表头删
 * 
 * @param L 
 * @return int  成功返回0,失败返回-1
 */
int Delete_Head(linklist L)
{
    if (L == NULL || L->len == 0)
    {
        printf("\n数据元素不存在，头删失败！\n\n");
        return -1;
    }
    linklist q = L->next;
    L->next = q->next;
    free(q);
    q = NULL;
    L->len--;
    return 0;
}

/**
 * @brief       单链表尾删
 * 
 * @param L 
 * @return int  成功返回0,失败返回-1
 */
int Delete_Rear(linklist L)
{
    if (L == NULL || L->len == 0)
    {
        printf("\n数据元素不存在，尾删失败！\n\n");
        return -1;
    }
    linklist p = L;
    for (size_t i = 1; i <= L->len-1; i++)
    {
        p = p->next;
    } 
    free(p->next);
    p->next = L;
    L->len--;
    return 0;
}

/**
 * @brief       单链表按位置插入 
 * 
 * @param L     单链表
 * @param pos   插入的位置
 * @param e     学生信息
 * @return int  成功返回0,失败返回-1
 */
int Insert_Position(linklist L,int pos,datatype e)
{
    if (L == NULL || L->len == 0 || pos < 1 || pos > L->len+1)
    {
        printf("\n单链表按位置插入失败！\n\n");
        return -1;
    }

    linklist p = Create_Node();
    if (p == NULL)
        return -1;

    linklist q = L;
    for (size_t i = 1; i <= pos-1; i++)
    {
        q = q->next;
    }
    //数据域
    p->data = e;
    //指针域
    p->next = q->next;
    q->next = p;
    L->len++;
    return 0;
}

/**
 * @brief       单链表按位置删除
 * 
 * @param L     单链表
 * @param pos   删除的位置
 * @return int  成功返回0,失败返回-1
 */
int Delete_Position(linklist L,int pos)
{
    if (L == NULL || L->len == 0 || pos < 1 || pos > L->len)
    {
        printf("\n单链表按位置删除失败！\n\n");
        return -1;
    }

    linklist p = L;
    for (size_t i = 1; i <= pos-1; i++)
    {
        p = p->next;
    }
    linklist q = p->next;
    p->next = q->next;
    free(q);
    q = NULL;
    L->len--;
    return 0;
}

/**
 * @brief       单链表按位置修改
 * 
 * @param L     单链表
 * @param pos   修改的位置
 * @param e     学生信息
 * @return int  成功返回0,失败返回-1
 */
int Updata_Position(linklist L,int pos,datatype e)
{
    if (L == NULL || L->len == 0 || pos < 1 || pos > L->len)
    {
        printf("\n单链表按位置修改失败！\n\n");
        return -1;
    }

    linklist p = L;
    for (size_t i = 1; i <= pos; i++)
    {
        p = p->next;
    }

    p->data = e;
    return 0;
}

/**
 * @brief       单链表按位置查找
 * 
 * @param L 
 * @param pos   查找的位置
 * @return int  成功返回0,失败返回-1
 */
int Search_Position(linklist L,int pos)
{
    if (L == NULL || L->len == 0 || pos < 1 || pos > L->len)
    {
        printf("\n单链表按位置查找失败！\n\n");
        return -1;
    }

    linklist p = L;
    for (size_t i = 1; i <= pos; i++)
    {
        p = p->next;
    }
    printf("您所查询的学生信息如下：\n");
    printf("\n姓名\t\t年龄\t\t分数\n");
    printf("\n%s\t\t%d\t\t%.1lf\n",p->data.name,p->data.age,p->data.score);
    return 0;
}

/**
 * @brief           单链表按元素查找
 * 
 * @param L         单链表
 * @param e         学生信息
 * @return int      成功返回位置,失败返回-1
 */
int Search_Data(linklist L,datatype e)
{
    if (L == NULL || L->len == 0)
    {
        printf("\n单链表按元素查找失败！\n\n");
        return -1;
    }

    linklist p = L;
    for (int i = 1; i <= L->len; i++)
    {
        p = p->next;
        if (strcmp(p->data.name,e.name)==0 && p->data.age==e.age && p->data.score==e.score)
        {
            return i;
        }
    }
    return -1;
}

/**
 * @brief       单链表按元素修改
 * 
 * @param L 
 * @param key   修改前的元素
 * @param e     修改后的元素
 * @return int  成功返回0,失败返回-1
 */
int Updata_Data(linklist L,datatype key,datatype e)
{
    int pos = Search_Data(L,key);
    if (pos == -1)
    {
        printf("\n单链表按元素修改失败!\n\n");
        return -1;
    }
    Updata_Position(L,pos,e);
    return 0;
}

/**
 * @brief           单链表按元素删除
 * 
 * @param L         单链表
 * @param e         删除的学生信息
 * @return int      成功返回0,失败返回-1
 */
int Delete_Data(linklist L,datatype e)
{
    int pos = Search_Data(L,e);
    if (pos == -1)
    {
        printf("\n单链表按元素删除失败!\n\n");
        return -1;
    }
    Delete_Position(L,pos);
    return 0;
}

/**
 * @brief           单链表逆置
 * 
 * @param L 
 * @return int      成功返回0,失败返回-1
 */
int Inversion_Link(linklist L)
{
    if (L == NULL || L->len == 0)
    {
        printf("\n单项链表逆置失败!\n\n");
        return -1;
    }
    linklist p = L->next;
    L->next = NULL;
    for (size_t i = 1; i <= L->len; i++)
    {
        linklist t = p->next;
        p->next = L->next;
        L->next = p;
        p = t;
    }
    return 0; 
}

/**
 * @brief       按成绩冒泡排序
 * 
 * @param L 
 */
void BubbleSort(linklist L)
{
    for (size_t i = 1; i < L->len; i++)
    {
        linklist p = L;
        int flag = 0;
        for (size_t j = 0; j < L->len-i; j++)
        {
            p = p->next;
            if (p->data.score < p->next->data.score)
            {
                datatype temp = p->data;
                p->data = p->next->data;
                p->next->data = temp;
                flag = 1;
            }
        }
        if (flag == 0)
            break;    
    } 
}

/**
 * @brief       链表空间释放
 * 
 * @param L 
 * @return linklist 
 */
linklist free_space(linklist L)
{
    if (L == NULL)
        return NULL;
    int count = L->len;
    for (size_t i = 0; i < count; i++)
    {
        Delete_Head(L);
    }
    free(L);
    L = NULL;
    return L; 
}
欲上层楼 再上层楼
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言实现链表中结构体嵌套
weixin_34301307的博客
07-31 2923
1.首先，定义两个结构体，一个用于定义链表，一个用于定义数据 // 定义数据相关的结构体 typedef struct Student{ int stu_id; char name[100]; }Stu; // 定义链表相关的结构体 typedef struct Node{ Stu student; struct Node *next; }Node,*L...
结构体嵌套构造链表
baowxz的专栏
05-15 617
结构体嵌套构造链表时，要使用指针的原因，原理
嵌入式必修数据结构——“链表”
m0_58168670的博客
06-19 330
首先我们从简单的开始讲，单链表，其余的双链表，循环链表也就是在这个基础上增加了更多的逻辑关系罢了。
C语言-链表
m0_59173154的博客
02-27 120
1.数据结构大致可以分为，线性结构和非线性结构 线性结构有 线性表，栈，队列，串等 非线性结构有 树，二叉树，图等 2.链表：是一种线性表，用指针相连的结点 3.存储方式：线性存储，链式存储 4.链式存储：存储是不连续的，每一个元素除了存储自身的信息外，还需要存储其后续元素的信息 5.链表每个结点由数据域和指针域组成，数据域用来保存自己的信息，指针域用来存储下一个结点的地址 6.单链表：结构体里面嵌套自己的结构体指针 创建一个单链表 1.初始化------创建链表头(init) .
C语言的那些小秘密之链表（一）
08-10
在Linux内核中，链表的实现更为复杂且高效，例如，它使用了自包含的链表头结构，允许在任何位置插入或删除节点，而且可以实现多级嵌套的链表。这些特性对于操作系统级别的内存管理和任务调度等操作至关重要。 了解...
用C语言编写的约瑟夫环程序
04-17
1. 使用单向循环链表存储结构模拟约瑟夫环。 2. 处理输入，接收初始的m值、n值和每个人对应的密码，建立链表。 3. 输出正确的出列顺序。 4. 提供测试数据，例如m的初值为20，n=7，每个人的密码分别为3、1、7、2、4、...
基于C语言的超市管理系统
01-18
单向链表允许动态地分配内存来存储商品信息，结构体的嵌套使得商品与购物车商品之间建立关联。文件操作用于持久化存储商品信息，程序启动时从文件读取数据到链表，结束时再将链表数据写回文件。 在编程过程中，...
全国计算机等级考试二级C考试大纲考纲.pdf
10-07
2. 链表：通过结构体构建单向链表，学习链表节点的添加、删除和查找操作。 六、位运算 1. 位运算符：掌握位移、按位与、按位或、按位异或和按位取反等位运算符的使用。 2. 位运算应用：利用位运算进行数据处理，如...
哈尔滨工业大学2018年计算机科学与技术学院《C语言程序设计》考试大纲1
08-03
* 动态内存分配函数和动态数据结构，单向链表的基本操作 7. 文件操作 * 文件的打开和关闭 * 二进制文件和文本文件 * 文件的顺序读写 三、试卷题型结构 * 单项选择题（10分） * 写出程序运行结果题（10分） * ...
【数据结构】单链表
KaguraQiu的博客
05-17 159
单链表是一种链式存取的数据结构
结构体的嵌套 自身嵌套 相互嵌套
热门推荐
杰儿__er 的博客
05-16 4万+
什么是结构体的嵌套？ 在结构体的定义中，结构体的成员又是另外一个结构体的变量。 结构体嵌套的问题有哪些？ 结构体的自引用，就是在结构体内部，包含指向自身类型结构体的指针。 结构体的相互引用，就是说在多个结构体中，都包含指向其他结构体的指针。 结构体应该注意的问题？ 结构体定义中可以嵌套其他结构体类型的变量，不可以嵌套自己这个类型的变量。 可以嵌套自己类型的指针。 *********...
链表嵌套（单向）
记忆中的美丽瞬间
08-19 3864
链表嵌套 测试环境:Visual-Studil Ultimate 2013 头文件：stdafx.h内容   #include #include #include structCAN_DEVICES*insert_DEVICE_LIST(structCAN_DEVICES*Temp);//子链表加入数据 voidprint_Device_List(structCAN_DEVIC
结构体 嵌套使用
me_badman的博客
03-30 2719
1.结构体嵌套<1>指向结构体的指针：struct student *p; struct student student1; p=&student1; 访问结构体变量成员的方式：p->age;(*p).age;sudent1.age;<2>一个结构体做另一个结构体的成员typedef struct item { char first[10]; char last[10]; int g
结构体嵌套自身的指针 单向链表
Tim的嵌入式之旅
06-16 1212
https://blog.csdn.net/huguozhang1986/article/details/46816175#include &lt;stdio.h&gt; struct Person { char *name; int age; //嵌套自己类型的指针 struct Person *child; }; int main(void) { struct Person k...
实现嵌套链表
u013917410的专栏
04-21 3212
程序设计里面作业的一道题，感觉我们的助教师兄出的很好，
数据结构(5.3_3)——由遍历序列构造二叉树
最新发布
m0_65240792的博客
07-25 101
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
循环链表和链表结构体定义的区别
08-25
循环链表和链表结构体的定义有一些区别。 链表结构体定义通常包含两个成员：一个是数据成员，用于存储节点的数据；另一个是指向下一个节点的指针。 ```c typedef struct Node { int data; struct Node* next; } Node; ``` 而循环链表的定义与链表结构体定义类似，但是在循环链表中，最后一个节点的指针不是指向空，而是指向第一个节点，形成一个闭环。 ```c typedef struct CircularNode { int data; struct CircularNode* next; } CircularNode; ``` 这样，从任意一个节点开始遍历，都可以遍历到链表中的所有节点。而在普通链表中，最后一个节点的指针为空，表示链表的结束。 另外，在插入和删除操作上，循环链表与链表结构体也有一些不同。在循环链表中，插入和删除操作需要考虑头节点和尾节点的特殊情况，以保持循环链表的连续性。 总之，循环链表是一种特殊的链表结构，在定义和操作上与普通链表有一些区别。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值