• 链表 C语言

    题目 1052: [编程入门]链表合并]

    1. //学习链表记录
    2. #include<stdio.h>
    3. #include<stdlib.h>
    4.  
    5. //结构体,然后区分结构体是内部的最后一行
    6. //struct Student *next;
    7. typedef struct Student{
    8. 	int num;
    9. 	int grade;
    10. 	struct Student *next; 
    11. }Node,*node;
    12.  
    13. //https://blog.csdn.net/endeavor_g/article/details/80552680
    14. //链表理论学习
    15. node creat(int n);//创建链表 
    16. void unite(node head1,node head2);// 结合链表 
    17. //这个有点像union联合函数
    18. void order(node head,int sum);//排序链表 
    19. void output(node head);//打印链表
    20.  
    21. //主函数
    22. int main(){
    23. 	int a,b;
    24. 	scanf("%d%d",&a,&b);//输入的两个链表元素数量 
    25. 	node head1=creat(a);//创造两个链表 ，head1，2为头节点 
    26. 	node head2=creat(b);
    27. 	unite(head1,head2);//结合两个链表 
    28. 	order(head1,a+b);//排序两个链表 
    29. 	return 0;
    30. } 
    31.  
    32. //创建链表
    33. /*
    34. LinkList *creat(int n){
    35. 	LinkList *head, *node, *end;//定义头节点，普通节点，尾部节点；
    36. 	head = (LinkList*)malloc(sizeof(LinkList));//分配地址
    37. 	end = head;         //若是空链表则头尾节点一样
    38. 	for (int i = 0; i < n; i++) {
    39. 		node = (LinkList*)malloc(sizeof(LinkList));
    40. 		scanf("%d", &node->score);
    41. 		end->next = node;
    42. 		end = node;
    43. 	}
    44. 	end->next = NULL;//结束创建
    45. 	return head;
    46. }
    47. */
    48. node creat(int n){
    49. 	node head=(node)malloc(sizeof(Node));//head为头结点 ，尾插创造 
    50. 	head->next=NULL;
    51. 	node p=head;//p为头指针 
    52. 	for(int i=0;i<n;i++){
    53. 		node q=(node)malloc(sizeof(Node));
    54. 		q->next=NULL;//q是结尾节点
    55. 		p->next=q;
    56. 		p=q;
    57. 		scanf("%d%d",&(*q).num,&(*q).grade);
    58. 	}
    59. 	return head;
    60. }
    61.  
    62. //结合两个链表
    63. void unite(node head1,node head2){
    64. 	node p;
    65. 	p=head1;
    66. 	while(p->next!=NULL)
    67. 	p=p->next;
    68. 	p->next=head2->next;
    69. 	head2->next=NULL;
    70. }
    71.  
    72. //排序两个链表
    73. void order(node head,int sum){
    74. 	node p=head->next;//p指向首结点 
    75. 	int t1,t2;//t1学号中间变量，t2成绩中间变量
    76. 	int cnt=0;//cnt为链表长度，这里选用冒泡排序 
    77. 	while(cnt<sum){
    78. 		node q=p;
    79. 		while(q->next!=NULL){
    80. 			if((q->num)>(q->next->num)){
    81. 				t1=q->num;
    82. 				q->num=q->next->num;
    83. 				q->next->num=t1;
    84. 				t2=q->grade;
    85. 				q->grade=q->next->grade;
    86. 				q->next->grade=t2;
    87. 			}
    88. 			q=q->next;
    89. 		}
    90. 		cnt++;
    91. 	} 
    92. 	output(head);
    93. }
    94.  
    95. //输出两个链表
    96. void output(node head){
    97. 	node p=head->next;
    98. 	node q;
    99. 	while(p!=NULL){
    100. 	printf("%d %d\n",p->num,p->grade);
    101. 	q=p;
    102. 	p=p->next;
    103. 	free(q);
    104. 	}
    105. }

    c语言链表详解（超详细）_Mr.Gzj的博客-CSDN博客_链表c语言

    题目 1052: [编程入门]链表合并_海琴烟Sunshine的博客-CSDN博客

    这个题目在我做之前,我是不会使用链表去运行的,因为我不太好使用链表,同时在我看了链表的相关代码后,太过于复杂,所以我直接使用结构去进行运行,代码如下:

    1. #include<stdio.h>
    2. typedef struct student{
    3.     int hao;
    4.     int mark;
    5. }stu;
    6.     stu a[100001];
    7. int main()
    8. {
    9.     int i,j,k,n,m;
    10.     int te,temp;
    11.     scanf("%d %d\n",&n,&m);
    12.     int s=n+m;
    13.     for(i=0;i<s;i++)
    14.     {
    15.     scanf("%d %d\n",&a[i].hao,&a[i].mark);   
    16.     }
    17.     
    18.     //采用冒泡排序法
    19.     for(j=1;j<i;j++)
    20.     {
    21.         for(k=0;k<i-j;k++)//从第一个数开始,一直到倒数第二个数,比较大小
    22.         //然后是第一个数开始,一直到倒数第三个数,比较大小,依次
    23.         {
    24.             if(a[k+1].hao<a[k].hao)
    25.             {
    26.                 temp=a[k].hao;
    27.                 a[k].hao=a[k+1].hao;
    28.                 a[k+1].hao=temp;
    29.                 
    30.                 te=a[k].mark;
    31.                 a[k].mark=a[k+1].mark;
    32.                 a[k+1].mark=te;
    33.             }
    34.         }
    35. }
    36.     for(i=0;i<s;i++)
    37.     {
    38.     printf("%d %d\n",a[i].hao,a[i].mark);   
    39.     }
    40.     return 0;
    41. }

    题目 1585: 

    蓝桥杯算法训练VIP-链表数据求和操作

    1. #include<stdio.h>
    2. #include<stdlib.h>
    3. int snum=0,sgra=0;
    4. typedef struct Student{
    5. 	int num;//假设num=实数
    6. 	int grade;//假设grade=虚数的前面数字
    7. 	struct Student *next; 
    8. }Node,*node;
    9. node creat(int n);//创建链表 
    10. //void unite(node head1,node head2);// 结合链表 
    11. void order(node head,int sum);//排序链表 
    12. void output(node head);//打印链表
    13. int main(){
    14. 	int a,b;
    15. 	node head=creat(10);//创造两个链表 ，head1，2为头节点 
    16. 	//node head2=creat(b);
    17. 	//unite(head1,head2);//结合两个链表 
    18. 	order(head,a+b);//排序两个链表
    19. 	//output(head1);
    20. 	return 0;
    21. } 
    22. node creat(int n){
    23. 	node head=(node)malloc(sizeof(Node));//head为头结点 ，尾插创造 
    24. 	head->next=NULL;
    25. 	node p=head;//p为头指针 
    26. 	for(int i=0;i<n;i++){
    27. 		node q=(node)malloc(sizeof(Node));
    28. 		q->next=NULL;
    29. 		p->next=q;
    30. 		p=q;
    31. 		scanf("%d %d",&(*q).num,&(*q).grade);
    32. 	}
    33. 	return head;
    34. }
    35.  
    36. /*
    37. void unite(node head1,node head2){
    38. 	node p;
    39. 	p=head1;
    40. 	while(p->next!=NULL)
    41. 	p=p->next;
    42. 	p->next=head2->next;
    43. 	head2->next=NULL;
    44. }*/
    45. void order(node head,int sum){
    46. 	node p=head->next;//p指向首结点 
    47. 	int t1,t2;//t1学号中间变量，t2成绩中间变量
    48. 	int cnt=0;//cnt为链表长度，这里选用冒泡排序 
    49. /*	while(cnt<sum){
    50. 		node q=p;
    51. 		while(q->next!=NULL){
    52. 			if((q->num)>(q->next->num)){
    53. 				t1=q->num;
    54. 				q->num=q->next->num;
    55. 				q->next->num=t1;
    56. 				t2=q->grade;
    57. 				q->grade=q->next->grade;
    58. 				q->next->grade=t2;
    59. 			}
    60. 			q=q->next;
    61. 		}
    62. 		cnt++;
    63. 	} */
    64. 	output(head);
    65. }
    66. void output(node head){
    67. 	node p=head->next;
    68. 	node q;
    69. 	while(p!=NULL){
    70. 	snum=snum+p->num;
    71. 	sgra=sgra+p->grade;
    72. 	//printf("%d %d\n",p->num,p->grade);
    73. 	q=p;
    74. 	p=p->next;
    75. 	free(q);
    76. 	}
    77. 	printf("%d+%di",snum,sgra);
    78. }

    下面这道求和的题目,直接在上面的程序上进行修改就可以,区别在于不需要排序和整合两个链表,只需要进行链表求和就可以,此处要注意修改的是输入和输出,然后把不需要的注释掉就可以了

    题目 1676: 

    数据结构-链表的基本操作

    1. #include<stdio.h>
    2. #include<stdlib.h>
    3. #include<string.h>                                                                                           
    4. typedef struct LN{                                                                                       
    5. 	int x;
    6. 	struct LN *next;                                                                                          
    7. }lnode,*Lnode;
    8. Lnode creat(int);//创建链表 
    9. void show(Lnode);//展示链表中的元素 
    10. void get(Lnode,int);//得到链表中的元素 
    11. void delete_(Lnode,int);//删除链表中的元素 
    12. void insert(Lnode,int,int);//插入
    13. int main(){
    14. 	int n;
    15. 	scanf("%d",&n);//列表内数量
    16. 	getchar();//输入字符
    17. 	Lnode head=creat(n);//创建链表
    18. 	
    19. 	int m;
    20. 	scanf("%d",&m);//m是第二行下面输入的行数
    21. 	getchar();
    22. 	char str[20];
    23. 	for(int i=0;i<m;i++){
    24. 		scanf("%s",str);
    25. 		getchar();
    26. 		
    27. 		
    28. 		if(strcmp(str,"show")==0){//strcmp对比str和show,如果相等则为0
    29. 			show(head);
    30. 		}
    31. 		if(strcmp(str,"get")==0){
    32. 			int a;
    33. 			scanf("%d",&a);
    34. 			getchar();
    35. 			get(head,a);
    36. 		}
    37. 		if(strcmp(str,"delete")==0){
    38. 			int b;
    39. 			scanf("%d",&b);
    40. 			getchar();
    41. 			delete_(head,b);
    42. 		}
    43. 		if(strcmp(str,"insert")==0){
    44. 			int c,d;
    45. 			scanf("%d%d",&c,&d);
    46. 			getchar();
    47. 			insert(head,c,d);
    48. 		}
    49. 	}
    50. 	return 0;
    51. }
    52. //创建链表
    53. Lnode creat(int n){
    54. 	Lnode head=(Lnode)malloc(sizeof(lnode));
    55. 	head->next=NULL;
    56. 	for(int i=0;i<n;i++){//采用头插法 
    57. 		Lnode p=(Lnode)malloc(sizeof(lnode));
    58. 		scanf("%d",&(*p).x);
    59. 		getchar();
    60. 		p->next=head->next;
    61. 		head->next=p;
    62. 	}
    63. 	return head;
    64. }
    65.  
    66. //show
    67. void show(Lnode head){
    68. 	Lnode p=head->next;
    69. 	if(p==NULL){
    70. 		printf("Link list is empty\n");
    71. 	}
    72. 	else{
    73. 		while(p!=NULL){
    74. 			printf("%d ",p->x);
    75. 			p=p->next;
    76. 		}
    77. 		printf("\n");
    78. 	}
    79. }
    80. //get
    81. void get(Lnode head,int a){
    82. 	Lnode p=head->next;
    83. 	int j=1;
    84. 	while(p&&j<a){
    85. 		p=p->next;
    86. 		j++;
    87. 	}
    88. 	if(!p||j>a){
    89. 		printf("get fail\n");
    90. 	}
    91. 	else{
    92. 		printf("%d\n",p->x);
    93. 	}
    94. }
    95.  
    96. //delete_
    97. void delete_(Lnode head,int b){
    98. 	Lnode p=head;
    99. 	int j=0;
    100. 	while(p->next&&j<b-1){
    101. 		p=p->next;
    102. 		j++;
    103. 	}
    104. 	if(!(p->next)||(j>b-1)){
    105. 		printf("delete fail\n");
    106. 	}
    107. 	else{
    108. 		Lnode q=p->next;
    109. 		p->next=q->next;
    110. 		printf("delete OK\n");
    111. 		free(q);
    112. 	}
    113. }
    114. //insert
    115. void insert(Lnode head,int c,int d){
    116. 	Lnode p=head;
    117. 	int j=0;
    118. 	while(p&&j<c-1){
    119. 		p=p->next;
    120. 		j++;
    121. 	}
    122. 	if(!p||(j>c-1)){
    123. 		printf("insert fail\n");
    124. 	}
    125. 	else{
    126. 		Lnode q=(Lnode)malloc(sizeof(lnode));
    127. 		q->next=p->next;
    128. 		p->next=q;
    129. 		q->x=d;
    130. 		printf("insert OK\n");
    131. 	}
    132. }

    题目 1676: 数据结构-链表的基本操作_海琴烟Sunshine的博客-CSDN博客

    最后一个基本操作,里面get delete  还有插入三个算法,主要看题目给的算法,里面的一些细节,一定要注意,比如说+1或者硕士p开头是什么

  • 相关阅读:
    Linux目录操作
    【全志R128填坑分享】适配LVGL界面图片和文字显示很虚，色阶明显的解决方法
    生产企业如何选择适合自己的工业网关？
    “我有一个大胆的想法”？Meta AI 新技术让你的思维图像一览无余！
    Java8中的Stream流
    光照静态烘焙
    ShardingSphere学习（超详细）
    在Vue3 + Vite项目中使用less
    vue 父子孙页面传值的多种方法
    无线充电器出口欧盟CE认证RED指令测试分析
  • 原文地址：https://blog.csdn.net/Lukegood/article/details/127622605