动态创建链表中包含链表和静态创建链表中包含链表

已于 2022-04-07 16:43:13 修改
阅读量414 收藏 6
点赞数
分类专栏： C语言 文章标签： 链表
于 2021-02-05 21:56:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46518045/article/details/113704545
版权

题目：采用两个结构体，一个结构体记录学生信息，一个记录年级信息。
情景：链表A，每个节点存放一个新链表,假设五个链表B1、B2、B3、B4、B5.
场景：一个年级，相当于链表A，该年级的五个班，相当于B1、B2、B3、B4、B5，
功能：录入成绩，语文、数学、英语，找出三科总分最高分、最低分，算出平均分。
说明：本题主要考的是怎样才能在链表中插入链表
动态创建链表只有怎样创建5个班每个班5个人，后面的功能录入成绩，语文、数学、英语，找出三科总分最高分、最低分，算出平均分，和静态链表是大同小异。
动态创建链表

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

struct person *sd;
struct person
{
        char name[10];
        int chinese;
        int math;
        int english;
        int sum;
        struct person *next1;
};

struct class
{
        struct class *next;
        struct person *stu;

};


struct class  *CreatLink(struct class *head)
{	
	struct class *new = (struct class *)malloc(sizeof(struct class));	
		new->next = head;
		head = new;

		
	return head;	
}





struct class *CreatMuch(int c,struct class *head)
{
	int i;
	 for(i=0;i<c;i++)
                {
                head  =  CreatLink(head);
                }


	return head;

}

struct person *CreatLink1(struct  person *head)
{
	struct person *new = (struct person *)malloc(sizeof(struct class));
                new->next1 = head;
                head = new;
                
	return head;
}
struct person *CreatMuch1(int p,struct person *head)
{
        int i;
         for(i=0;i<p;i++)
                {
                head  =  CreatLink1(head);
                }


        return head;

}




void classconnectperson(int c,struct class *cs)
{	
	
	int i;
	int cnt ;
        int p;
	struct class *change =  (struct class *)malloc(sizeof(struct class));

        sd =NULL;
        printf("input 1 class the number of student \n");
        scanf("%d",&p);
        sd = CreatMuch1(p,sd);
        cs->stu = sd;
	
        printf("input 2 class the number of student \n");
        scanf("%d",&p);
        sd = CreatMuch1(p,sd);
        cs->next->stu = sd;
	
	printf("input 3 class the number of student \n");
        scanf("%d",&p);
        sd = CreatMuch1(p,sd);
        cs->next->next->stu = sd;

	printf("input 4 class the number of student \n");
        scanf("%d",&p);
        sd = CreatMuch1(p,sd);
        cs->next->next->next->stu = sd;

	printf("input 5 class the number of student \n");
        scanf("%d",&p);
        sd = CreatMuch1(p,sd);
        cs->next->next->next->next->stu = sd;
	
}





void print(struct class *head)
{
		int cnt = 0;
	while(head != NULL){

				cnt++;
				head = head->next;
					
				}

		printf("class:%d\n",cnt);

}


void print1(struct person *head)
{
                int cnt = 0;
        while(head!= NULL){

                                cnt++;
                                head = head->next1;

                                }

                printf("person:%d\n",cnt);

}

int main()
{		
		int c;
		struct class *cs;
		cs = NULL;
                printf("please input class\n");
                scanf("%d",&c);

		cs =CreatMuch(c,cs);		
		print(cs);
		classconnectperson(c,cs);
		print1(sd);

		printf("creat person successful\n");
	return 0;
}

说明：指针用函数传参时也是临时变量不会导致main函数的指针发生偏移（也就是传过去过后函数结束后就被释放），如果不想返回的话那么就需要传二级指针进去，就可以不返回了。

静态创建链表

#include <stdio.h>

struct person
{
	char name[10];
        int chinese;
        int math;
        int english;
	int sum;
	struct person *next;
};

struct class
{	

	struct class *next1;
	struct person *head;
};

int getGrade(struct person *head,int cnt)
{	
	struct person *p;
	int i = 0;
	++cnt;
	 p = head;
	while(p != NULL){
			++i;
	 printf("please input b%d%d name:\n",cnt,i);
        scanf("%s",p->name);
        printf("please input b%d%d chinese:\n ",cnt,i);
        scanf("%d",&p->chinese);
         printf("please input b%d%d math:\n ",cnt,i);
        scanf("%d",&p->math);
         printf("please input b%d%d english:\n ",cnt,i);
        scanf("%d",&p->english);
			p->sum = p->chinese + p->math + p->english;
			p = p->next;
				putchar('\n');
				}
		return cnt;
}
int prin(struct person *head,int cnt)
{	
	struct person *p;
	p=head;
	++cnt;
	printf("##############################################%dclass#########################################\n",cnt);
	while(p!=NULL){
			printf("%s\n",p->name);
			printf("chinese:%d math:%d english:%d\n sum:%d\n ",p->chinese,p->math,p->english,p->sum);
					p=p->next;
				}   


					return cnt;
}

struct person *getmaxclass(struct person *head)
{
	struct person *p;
		struct person *max;
	
		p = head;
	        max=p;               
	
		while(p != NULL){
				if(max->sum <= p->sum ){
						max=p;
						}
						
						p=p->next;
					}
		return max;
		

}

struct person *getmax(struct class *head)
{	
	struct class *p;
	p = head;
  	struct person* max1=getmaxclass(p->head);
	struct person* max2 = getmaxclass(p->next1->head);
	struct person* max3 = getmaxclass(p->next1->next1->head);
	struct person* max4 = getmaxclass(p->next1->next1->next1->head);
	struct person* max5 = getmaxclass(p->next1->next1->next1->next1->head);
	

	if(max1->sum<=max2->sum)
	{
		max1=max2;
		}	
	 if(max1->sum<=max3->sum)
	{
		max1=max3;
		}
		
	 if(max1->sum<=max4->sum)
        {
                max1=max4;
                }
	 if(max1->sum<=max5->sum)
        {
                max1=max5;
                }

	return max1;




}

struct person *getminclass(struct person *head)
{
        struct person *p;
                struct person *min;

                p = head;
                min=p;

                while(p != NULL){
                                if(min->sum >= p->sum ){
                                                min=p;
                                                }

                                                p=p->next;
                                        }
                return min;


}
struct person *getmin(struct class *head)
{
        struct class *p;
        p = head;
        struct person* min1=getminclass(p->head);
        struct person* min2 = getminclass(p->next1->head);
        struct person* min3 = getminclass(p->next1->next1->head);
        struct person* min4 = getminclass(p->next1->next1->next1->head);
        struct person* min5 = getminclass(p->next1->next1->next1->next1->head);

        if(min1->sum>=min2->sum)
        {
                min1=min2;
                }
         if(min1->sum>=min3->sum)
        {
                min1=min3;
                }

         if(min1->sum>=min4->sum)
        {
                min1=min4;
        }
         if(min1->sum>=min5->sum)
        {
                min1=min5;
                }

        return min1;




}

float getave(struct class *head,int cnt)
{
		struct class* p;
		   p=head;
		int sum=0;
		float ave;
	while(p->head!= NULL)
	{
		sum+=p->head->sum;
		p->head=p->head->next;
			
		}

	 while(p->next1->head!= NULL)
        {
                sum+=p->next1->head->sum;
                p->next1->head=p->next1->head->next;
                }

	while(p->next1->next1->head!= NULL)
        {
                sum+=p->next1->next1->head->sum;
               p->next1->next1->head =p->next1->next1->head->next;
                }

	 while(p->next1->next1->next1->head!= NULL)
        {
                sum+=p->next1->next1->next1->head->sum;
                p->next1->next1->next1->head=p->next1->next1->next1->head->next;
                }

	while(p->next1->next1->next1->next1->head!= NULL)
        {
                sum+=p->next1->next1->next1->next1->head->sum;
                p->next1->next1->next1->next1->head=p->next1->next1->next1->next1->head->next;
                }

		ave =( (float)sum)/cnt;
		
		return ave;











}



int main()
{	
	   int cnt = 0;
            int i = 0;


         struct class B1;
        struct class B2;
        struct class B3;
        struct class B4;
        struct class B5;

	struct person a1 = {"aa",0,0,0,0,NULL};
        struct person a2 = {"aa",0,0,0,0,NULL};
        struct person a3 = {"aa",0,0,0,0,NULL};
        struct person a4 = {"aa",0,0,0,0,NULL};
        struct person a5 = {"aa",0,0,0,0,NULL};
	
	struct person b1 = {"aa",0,0,0,0,NULL};
        struct person b2 = {"aa",0,0,0,0,NULL};
        struct person b3 = {"aa",0,0,0,0,NULL};
        struct person b4 = {"aa",0,0,0,0,NULL};
        struct person b5 = {"aa",0,0,0,0,NULL};
	
	 struct person c1 = {"aa",0,0,0,0,NULL};
        struct person c2 = {"aa",0,0,0,0,NULL};
        struct person c3 = {"aa",0,0,0,0,NULL};
        struct person c4 = {"aa",0,0,0,0,NULL};
        struct person c5 = {"aa",0,0,0,0,NULL};
	
	 struct person d1 = {"aa",0,0,0,0,NULL};
        struct person d2 = {"aa",0,0,0,0,NULL};
        struct person d3 = {"aa",0,0,0,0,NULL};
        struct person d4 = {"aa",0,0,0,0,NULL};
        struct person d5 = {"aa",0,0,0,0,NULL};

	 struct person e1 = {"aa",0,0,0,0,NULL};
        struct person e2 = {"aa",0,0,0,0,NULL};
        struct person e3 = {"aa",0,0,0,0,NULL};
        struct person e4 = {"aa",0,0,0,0,NULL};
        struct person e5 = {"aa",0,0,0,0,NULL};
      		
		 B1.next1=&B2;
       		 B2.next1=&B3;
       		 B3.next1=&B4;
       		 B4.next1=&B5;

		

		  B1.head = &a1;
		 a1.next = &a2;
                 a2.next = &a3;
                 a3.next = &a4;
                 a4.next = &a5;

		  B2.head = &b1;
                 b1.next = &b2;
                 b2.next = &b3;
                 b3.next = &b4;
                 b4.next = &b5;

		 B3.head = &c1;
                 c1.next = &c2;
                 c2.next = &c3;
                 c3.next = &c4;
                 c4.next = &c5;

		 B4.head = &d1;
                 d1.next = &d2;
                 d2.next = &d3;
                 d3.next = &d4;
                 d4.next = &d5;
		 
		B5.head = &e1;
                 e1.next = &e2;
                 e2.next = &e3;
                 e3.next = &e4;
                 e4.next = &e5;






		

                cnt=getGrade(B1.head,cnt);
                cnt= getGrade(B2.head,cnt);
           	cnt= getGrade(B3.head,cnt);
                cnt= getGrade(B4.head,cnt);
                cnt= getGrade(B5.head,cnt);
               
	
          	i= prin(B1.head,i);
              	i= prin(B1.next1->head,i);
		i= prin(B1.next1->next1->head,i);
		i= prin(B1.next1->next1->next1->head,i);
		i= prin(B1.next1->next1->next1->next1->head,i);
  		 struct person* min=getmin(&B1);
		struct person* max=getmax(&B1);
		float ave=getave(&B1,25);
	
printf("max: %s\n  chinese:%d math:%d english:%d max:%d \n",max->name,max->chinese,max->math,max->english,max->sum);
printf("min: %s\n  chinese:%d math:%d english:%d min:%d \n",min->name,min->chinese,min->math,min->english,min->sum);
printf("ave:%f\n",ave);














	return 0;
}
kpler
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
双链表嵌套实现的几行数据的链表打印输出数据最后一行的数据覆盖前面的数据问题解决分析
dyx9010的专栏
09-05 418
双链表嵌套输出数据最后一行数据覆盖前面的数据解决分析，字符指针型变量改为字符数组问题得到解决
实现嵌套链表
u013917410的专栏
04-21 3210
程序设计里面作业的一道题，感觉我们的助教师兄出的很好，
【数据结构】链式存储：链表
m0_72161237的博客
01-01 1969
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 而链表分为单向或双向、带头或不带头、循环或非循环，组合起来就有8种链表结构。 接下来我们会学习：单向不带头非循环链表（笔试、面试都是这个结构）和双向不带头非循环链表（集合类底层这样操作）
链表嵌套链表实现学生管理系统
d0203的博客
03-15 250
【代码】链表嵌套链表实现学生管理系统。
C语言链表嵌套链表,C语言里链表节点的数据里嵌套另一个链表数据头指针的问题（求解答）...
weixin_28900437的博客
05-21 952
满意答案liminyang2014.01.10要在第二条语句前先创建linklist_2 *类型的变量top2_，和flight *类型的变量data1，即：linklist_2 *top2_=(linklist_2 *)malloc(sizeof(linklist_2));flight *data1=(flight *)malloc(sizeof(flight));然后data1->top...
C语言静态链表和动态链表
09-02
链表是计算机科学中一种重要的数据结构，尤其在C语言中，它被广泛用来处理动态数据集合。链表分为静态链表和动态链表，两者的...在C语言编程中，理解和掌握静态链表与动态链表的原理和使用方法是非常基础且重要的技能。
077创建动态链表_动态链表_
09-30
在创建动态链表时，我们需要了解以下几个关键概念： 1. **节点（Node）**：链表的基本组成单位是节点，每个节点包含两部分：数据域（用于存储信息）和指针域（用于存储下一个节点的地址）。在C++中，可以这样定义一...
C语言实现静态链表
08-18
在静态链表中，每个结点的结构体中都包含一个整数型的数据域和一个整数型的游标域。游标域用来存储当前结点的下一个结点的索引。静态链表的初始化时，只有最后一个结点的游标域是0，表示头指针，并没有任何分配的...
线性结构及其应用，顺序表，链表，静态链表
03-30
在静态链表中，每个节点的存储空间是预先分配好的，而不是动态申请。这意味着静态链表的元素在内存中是连续的，但是每个节点依然包含指向下一个节点的指针。静态链表的操作与普通链表类似，但在一些情况下，由于内存...
linux内核链表（一套精彩的链表数据结构）
04-27
内核链表的构造与操作： 在Linux内核中使用了大量的链表结构来组织数据。这些链表大多数采用了include。/linux/list.h中实现的一套精彩的链表数据结构。 内核的链表具备双链表功能，实际上，通常它都的组织成双向循环链表。
在一个链表中插入另一个链表中
nidie508的博客
09-24 3192
设指针la和lb分别指向两个无头结点单链表中的首元结点，试设计从表la中删除自第i个元素起共len个元素，并将它们插入到表lb的第j个元素之后的算法。 #include "stdio.h" #include "stdlib.h" struct student { int data; struct student *next; }; struct student *CreateLista(); ...
C语言链表嵌套链表,这个嵌套链表如何赋值
weixin_42501892的博客
05-21 774
该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include#include#includestruct nodeyans;struct node{char het[21] = {'\0'};char mingc[21] = {'\0'};int shul;struct nodeyans * pp;//把struct nodeyan链表嵌套在struct node的链表struct node* n...
【数据结构与算法】一套链表 OJ 带你轻松玩转链表
bit me的博客
12-03 1911
十道链表OJ轻松上手，拓宽你对链表的认知
链表嵌套（单向）
记忆中的美丽瞬间
08-19 3862
链表嵌套 测试环境:Visual-Studil Ultimate 2013 头文件：stdafx.h内容   #include #include #include structCAN_DEVICES*insert_DEVICE_LIST(structCAN_DEVICES*Temp);//子链表加入数据 voidprint_Device_List(structCAN_DEVIC
关于链表的总结(一套链表定义)
蜗牛up
12-30 774
/*链表定义*/ typedef struct node *link; struct node { int item; link next; }; /*结点内存分配 *数据项引用x->item，x->next * */ link x=malloc(sizeof *x);x->itme=1;x->next=NULL; /*删除结点,t为删除结点指针，
链表基础_01__嵌套类
爱吃芒果的薯条 的博客
04-14 404
链表基本操作_02_嵌套类一、示例 一、示例 main.cpp #include <iostream> #include "ThreeLetterList.h" using namespace std; int main() { cout << "链表基本操作_02_嵌套类" << endl; ThreeLetterList L; ...
链表 详解（单链表、循环链表、双向链表、Linux内核“共享”双链表）C/C++
qq_54169998的博客
11-17 1577
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
静态创建链表与动态创建链表区别
最新发布
05-25
静态创建链表是在编译时就确定了链表的大小，需要手动为每个节点分配内存空间，不支持动态扩容和缩容。而动态创建链表则是在运行时动态地为每个节点分配内存空间，支持动态扩容和缩容。 静态创建链表的优点是空间...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值