任务三 链表

最新推荐文章于 2023-09-20 20:19:36 发布
最新推荐文章于 2023-09-20 20:19:36 发布
阅读量589 收藏 9
点赞数 3
分类专栏： 湖北师范大学 计算机应用与编程学期实训 文章标签： 链表 数据结构 c语言 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74891783/article/details/128558987
版权

1.创建链表

（1）【基本要求】
从键盘输入一组整数，创建单向链表，并输出链表中的数据。
样例输入：2 5 7 6 3 4
样例输出：2 5 7 6 3 4
（2）【功能实现】

#include<stdio.h>
#include<stdlib.h>
#define N 4 /*链表的长度*/ 
struct Node //链表结点的结构体 
{ 
	int data; //结点的值
	struct Node *next; //指向下一个结点的指针 
}; 
//创建n个结点的链表，返回链表的首结点地址 
Node* createList(int n); 
//输出头结点地址为first的链表 
void printList(Node *first); 
//释放头结点地址为first的链表所有结点占据的内存空间 
void destoryList(Node *first);
int main() 
{ 
	Node *list; 
	printf("请输入%d个数以建立链表\n",N); 
	//创建N个结点的链表，链表首结点地址=>list 
	list=createList(N); 
	printList(list); //输出头结点地址为list链表
	destoryList(list); //释放头结点地址为list的链表所有结点占据的内存空间 
	printf("\n"); 
} 
//创建n个结点的链表，返回链表的首结点地址 
Node* createList(int n) 
{ /*尾插法建立链表*/
  //first:指向首结点，last：指向最后一个结点，t指向临时结点
    Node *t,*first,*last; 
    int i; 
  //分配一个结点的空间 => 第1个结点 
    first=(Node *)malloc(sizeof(Node)); 
    scanf("%d",&first->data); //输入第一个结点的值 
    last=first; //只有一个结点，既是队首也是队尾 
   //创建其余的n-1个结点 
	for(i=n-1;i>0;i--) 
	{ 
	//分配一个结点的空间 => 临时结点t 
    	t=(Node *)malloc(sizeof(Node)); 
    	scanf("%d",&t->data); //输入下一个结点的值
		last->next=t; //将临时结点t插入到链表的尾部
		last=t; //临时结点t变成链表的尾部
	} 
		last->next=NULL; //队尾结点的下一个结点为空 
		return first; 
} 
/*遍历链表并输出*/
void printList(Node *first) 
{ 
	Node *p=first;
	while(p!=NULL) 
	{ 
		printf("%3d",p->data); 
		p=p->next; 
	} 
	printf("\n"); 
} 
//释放头结点地址为first的链表所有结点占据的内存空间 
//free(p)释放指针p指向的结点占据的内存空间
//free函数，在stdlib.h头文件中定义 
void destoryList(Node *first) 
{ 
	Node *p=first,*temp;
  	while(p!=NULL) 
	{ 
//使用过多少次malloc函数分配内存，就要使用多少次free函数释放内存 
    	temp=p->next; //暂存下一个结点的地址 
    	free(p); //释放当前结点的内存空间 
    	p=temp; // p指向下一个结点 
	} 
}

（3）【运行结果】

在这里插入图片描述

2.链表合并

（1）【基本要求】
从键盘输入两组由小到大的整数，每组数据创建一个链表。然后将两个链表合并，合并后的链表仍然保持由小到大的顺序。最后输出合并后的链表。
样例输入：
1 2 5 7
2 3 6 8 9
样例输出：1 2 2 3 5 6 7 8 9
（2）【功能实现】
代码一：

#include<stdio.h> 
#include<stdlib.h> 
#define N1 4 //链表La的长度 
#define N2 5 //链表Lb的长度 
struct Node{ 
	int data; 
	struct Node *next;  
}; 
Node* createList(int n);   
Node* mergeList(Node *la,Node *lb);//两个有序链表合并，返回合并后链表的首结点地址 
void printList(Node *p);  
void destoryList(Node *first);
int main(){ 
	Node *la,*lb; 
	printf("请按照升序，输入%d个数以建立链表La\n",N1);
	//创建N1个结点的链表，链表首结点地址=>la 
	la=createList(N1); 
	printf("请按照升序，输入%d个数以建立链表Lb\n",N2);
	//创建N2个结点的链表，链表首结点地址=>lb 
	lb=createList(N2); 	
	la=mergeList(la,lb);//合并两链表=>la 
	printList(la);//输出链表la 
	destoryList(la);//释放合并后的链表所有结点占据的内存空间 
	printf("\n");  
} 
Node* createList(int n){ 
    Node *t,*first,*last; 
    int i;  
    first=(Node *)malloc(sizeof(Node));    
	scanf("%d",&first->data); 
    last=first;    
    for(i=n-1;i>0;i--) 
    { 
        t=(Node *)malloc(sizeof(Node));         
		scanf("%d",&t->data); 
        last->next=t; 
        last=t; 
    } 
 last->next=NULL; 
    return first; 
} 
Node* mergeList(Node *la,Node *lb){   
    Node *first=NULL;  
    Node *last=NULL;   
    while(la&&lb) {
	        if(la->data<lb->data) 
         {   
	        if(first==NULL)  
	        {     
			first=la;
		        last=la;
	        }
	        else 
	        {     
		      last->next=la;
              last=la;
               }               
			la=la->next;  
	}
        else if (la->data>lb->data) 
        {          
	     if(first==NULL)
	       {    
            first=lb;
	            last=lb;
	       }
	       else 
	       {     
		     last->next=lb;
	             last=lb;
	       }             
		   lb=lb->next; 
        } 
        else 
        {     
	       if(first==NULL)
	       {      
		      first=la;
		      last=la;
	       } 
    	      else      {             
			last->next=la; 
  	        last=la;
	       }
   	       la=la->next;    
			last->next=lb; 
            last=lb;             
			lb=lb->next; 
        } 
    } 
    if(la)  // la≠0
	    last->next=la;
    if(lb)  // lb≠0
		last->next=lb;
    return first; 
} 
void printList(Node *first) 
{ 
     Node *p=first;
     while(p!=NULL){          
	 printf("%3d",p->data); 
        p=p->next; 
     } 
     printf("\n"); 
} 
void destoryList(Node *first) 
{ 
    Node *p=first,*temp;
    while(p!=NULL){                       
	 temp=p->next;  
   	   free(p); 
   	   p=temp; 
   } 
}

代码二：

#include<stdio.h> 
#include<stdlib.h> 
#define N1 4 /*链表La的长度*/  
#define N2 5 /*链表Lb的长度*/ 
struct Node  //链表的结点 
{ 
	int data; 				
	struct Node *next; 
};  
Node* createList(int n); 
/*将结点t连接到last指向的结点后面 
  在函数中，由于first、last的值可能被修改， 还需要带回到调用的函数，
                  所以实参是fisrt、last的地址 
  firstPoint=&first 
  lastPoint=&last */
void append(Node **firstPoint,Node **lastPoint,Node *t);  
//两个有序链表合并，返回合并后链表的首结点地址 
Node* mergeList(Node *la,Node *lb); 
//打印链表 
void printList(Node *p); 
//释放头结点地址为first的链表所有结点占据的内存空间 
void destoryList(Node *first);
int main() 
{ 
	Node *la,*lb; 
	printf("请按照升序，输入%d个数以建立链表La\n",N1); 
	//创建N1个结点的链表，链表首结点地址=>la 
	la=createList(N1); 
	printf("请按照升序，输入%d个数以建立链表Lb\n",N2); 
	//创建N2个结点的链表，链表首结点地址=>lb 
	lb=createList(N2); 
	la=mergeList(la,lb); //合并两链表=>la 
	printList(la); //输出链表la 
	destoryList(la); //释放合并后的链表所有结点占据的内存空间 
	printf("\n");  
} 

//创建n个结点的链表，返回链表的首结点地址   
Node* createList(int n) 
{ /*尾插法建立链表*/
    Node *t,*first,*last; 
    int i; 
    //分配一个结点的空间 => 第1个结点 
    first=(Node *)malloc(sizeof(Node)); 
    scanf("%d",&first->data); //输入第一个结点的值 
    last=first; //只有一个结点，既是链表的首部也是链表的尾部   
    //创建其余的n-1个结点 
    for(i=n-1;i>0;i--) 
    { 
	//分配一个结点的空间 => 临时结点t 
        t=(Node *)malloc(sizeof(Node)); 
        scanf("%d",&t->data); //输入下一个结点的值
        last->next=t;  //将临时结点t插入到链表的尾部
        last=t; //临时结点t变成链表的尾部
    } 
    last->next=NULL; //链表的尾部结点的下一个结点为空 
    return first; 
}

 //将结点t接到首结点地址为*firstPoint，尾结点地址为 *lastPoint 的链表的尾部
void append(Node **firstPoint,Node **lastPoint,Node *t)
{
	if(*firstPoint==NULL) //合并后的链表为空 
	        //结点t既作为合并后的头结点 
		*firstPoint=t;
	else //合并后的链表不为空
	        //将结点t插入到合并后链表的尾部 
		(*lastPoint)->next=t;
        *lastPoint=t;//t变成并后链表的最后一个结点 
} 

//两个链表合并，返回合并后链表的首结点地址 
Node* mergeList(Node *la,Node *lb)  
{   /*将两个链表按递增序列排序*/
    Node *first=NULL; //合并后链表的首结点地址 
    Node *last=NULL;  //合并后链表的尾结点地址
    //链表la和链表lb都不为空（都没有到最后）  
    while(la&&lb) 
    { 
    	 //链表la当前结点的值<链表lb当前结点的值
        if(la->data<lb->data) 
        {
        	//将la的第1个结点，连到last的后面 
         	append(&first,&last,la);
                la=la->next; //链表la指针移向下一个结点 
	}
        else if (la->data>lb->data) //链表la当前结点的值>链表lb当前结点的值
	{
        	//将lb的第1个结点，连到last的后面 
		append(&first,&last,lb);
           	lb=lb->next; //链表lb指针移向下一个结点
        } 
        else //链表la当前结点的值=链表lb当前结点的值

        {  

        	//将la的第1个结点，连到last的后面 
		append(&first,&last,la);
   	       	la=la->next; //链表la指针移向下一个结点
   	       //将lb的第1个结点，连到last的后面  
		append(&first,&last,lb);
           	lb=lb->next; //链表lb指针移向下一个结点
        } 
    } 
    //链表la不为空，链表lb为空 
    if(la)  // la≠0
	    last->next=la;
   //链表lb不为空，链表la为空 
    if(lb)  // lb≠0
		last->next=lb;
    return first; 
} 

/*遍历链表并输出*/
void printList(Node *first) 
{ 
   Node *p=first;
   while(p!=NULL) 
   { 
       printf("%3d",p->data); 
       p=p->next; 
   } 
   printf("\n"); 
} 

//释放头结点地址为first的链表所有结点占据的内存空间 
//free(p)释放指针p指向的结点占据的内存空间
//free函数，在stdlib.h头文件中定义 
void destoryList(Node *first) 
{ 
   Node *p=first,*temp;
   while(p!=NULL) 
   { 
           //使用过多少次malloc函数分配内存，就要使用多少次free函数释放内存 
           temp=p->next; //暂存下一个结点的地址 
   	   free(p); //释放当前结点的内存空间 
   	   p=temp;  // p指向下一个结点 
   }  
}

（3）【运行结果】
在这里插入图片描述

ybi8bo007
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[9-JZ22 链表中倒数最后k个结点]
qq_26471745的博客
03-28 1149
描述 输入一个长度为 n 的链表，设链表中的元素的值为 ai ，返回该链表中倒数第k个节点。 如果该链表长度小于k，请返回一个长度为 0 的链表。 数据范围：0≤n≤10^5，0≤ai​≤10^9，0≤k≤10^9 要求：空间复杂度 O(n)，时间复杂度 O(n) 进阶：空间复杂度 O(1)，时间复杂度 O(n) 例如输入{1,2,3,4,5},2时，对应的链表结构如下图所示： 其中蓝色部分为该链表的最后2个结点，所以返回倒数第2个结点（也即结点值为4的结点）即可，系统会打印后面所有的节点
链表基础1（超简单）--创建一个长度为n的单链表
玫瑰花店的博客
10-30 9585
首先我们来了解一下什么是链表？ 通俗的来说链表就是一种链式存储结构，大家可以抽象理解一下把他想象成一个铁链，铁链不是由一个个铁环，环环相扣组成的嘛！那么每个铁环就可以叫做一个节点，如果我们再在每个铁环上面系上两个个小盒子，那么这两个小盒子一个叫做数据域就是存放每个节点数据的地方一个叫做指针域这个就是存放下一个节点（铁环）地址的地方。可能这样说还有点抽象，直接上图。 这就是链表里面一个节点的样子，下面我们给多个节点串起来形成链表！ 我给每个节点的地址设为A,B,C。注意看第一个节点的指针域存放的是第二个节
C语言尾插法建立一个大小为n的链表
weixin_46130146的博客
05-14 549
尾插法建立一个大小为n的链表并换行输出。 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> typedef struct Node { int num; struct Node *next; }LNode; void creat (LNode *H, int n) { LNode *p, *r; int x, i; r = H; for (i =
每日一题之链表
m0_50290125的博客
10-11 126
描述 输入一个长度为 n 的链表，设链表中的元素的值为 ai ，输出一个链表，该输出链表包含原链表中从倒数第 k 个结点至尾节点的全部节点。 如果该链表长度小于k，请返回一个长度为 0 的链表。 数据范围：0 \leq n \leq 10^50≤n≤105，0 \leq a_i \leq 10^90≤ai​≤109，0 \leq k \leq 10^90≤k≤109 要求：空间复杂度O(n)O(n)，时间复杂度O(n)O(n) 进阶：空间复杂度O(1)O(1)，时间复杂度O(n)O...
C语言建立循环单链表并输出
Xenoverse的博客
12-12 5703
Description  依次输入n（n&gt;0)个整数，建立带表头结点的循环单链表，并依次输出单链表中的元素值。 提示： 结点结构如下： typedef struct Node {      int data;       struct Node *next; }LNode,*LinkList; 要求： （1）编写函数，从键盘输入n个数，建立带头结点的循环单链表。  （2...
任务控制块及其链表
11-12
（2）设计函数OSInit()对全局变量进行初始化，定义一个数组OS_TCB OSTCBTbl[]，创建单向链表OSTCBFreeList 把数组OSTCBTbl的各个元素链接，生成一个空任务链表OSTCBFreeList； （3）设计函数OS_TCBInit(INT8U prio)...
stm32f103 双向链表
08-16
例如，你可以创建一个任务节点，每个节点包含任务的优先级、状态和执行函数，然后用链表来管理这些任务。 总之，STM32F103上的双向链表实现是嵌入式系统开发中一种灵活且强大的数据结构，它允许我们在有限的内存...
合并有序链表1
08-03
在给定的编程问题中，任务是合并两个已经按升序排列的单链表，创建一个新的升序链表。这是一个常见的算法问题，通常出现在数据结构和算法的学习中，例如LeetCode等在线编程挑战平台。这个问题涉及到链表的操作，包括...
链表实现队列
09-24
队列是一种先进先出（First In First Out, FIFO）的数据结构，常用于任务调度、缓存管理和多线程同步等场景。 链表是一种动态数据结构，它不像数组那样预先分配固定大小的存储空间。在链表中，每个元素称为节点，每...
单链表的基本操作
weixin_45646463的博客
12-22 385
一、向链表中插入数据 首先先创建一个节点，判断头节点是否为空，如果为空的话就将将新节点付给头节点，如果不为空的话遍历找出尾节点，将新节点赋给为节点的后继节点。 public class Node { Node next = null; int data; public Node(int data) { this.data = data; } } *****************...
2020-10-03
keven03的博客
10-03 644
这个怎么一直通过不了？ ![graph TD; A-->B; B-->C;](https://img-blog.csdnimg.cn/20201003210519624.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tldmVuMDM=,size_16,color_FFFFFF,t_70) 代码https://paste.ubuntu.
数据结构作业5--单链表
qq_41464448的博客
09-19 2053
6-1 带头结点的单链表就地逆置 （10 分） 本题要求编写函数实现带头结点的单链线性表的就地逆置操作函数。L是一个带头结点的单链表，函数ListReverse_L(LinkList &amp;L)要求在不新开辟节点的前提下将单链表中的元素进行逆置，如原单链表元素依次为1,2,3,4，则逆置后为4,3,2,1。 函数接口定义： void ListReverse_L(LinkList &am...
PTA-单链表基本操作
FORER_UNNER的博客
09-20 1048
请编写程序实现单链表插入、删除结点等基本算法。给定一个单链表和一系列插入、删除结点的操作序列，输出实施上述操作后的链表。单链表数据域值为整数。
单链表操作
qq_41932243的博客
09-12 594
题目： 单链表操作     功能：   1. 建立一个含有若干个整数的单链表存储结构； 2. 输出单链表各节点的值； 3. 查询第I个结点的值，并输出； 4. 在第I个结点之后插入一个值为X的结点。 5. 删除第I个结点。       #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #define LEN   sizeof(str...
逆转单链表
drtfyguhil的博客
05-13 500
题目描述 将链表的元素逆转，要求算法的空间复杂度为O(1). 输入 输入包括两行。 第一行是一个整数n，表示链表中的元素个数。 第二行是n个空格分开的整数，为各元素值。 输出 输出逆转后的链表。 样例输入 5 1 2 3 4 5 样例输出 5 4 3 2 1 #include<iostream> #include<iomanip> using namespace std; #define OK 1 #define ERROR 0 #define OVERFLO
单链表的创建，插入，输出操作
qq_53679247的博客
10-05 2018
#include<stdio.h> #include<stdlib.h> struct MyStruct { int data; struct MyStruct * next; }; void chuangjian_and_charu(struct MyStruct* head,struct MyStruct*a)//头插法，将新的节点插在头结点之后。 { int n; scanf_s("%d", &n); for (int i = 0; i < n;..
输入一组数，构建有序链表 （C语言实现）
阳光大男孩！！！的博客
07-04 2841
要求说明 输入一组数，构建有序链表。 整体思路 用数组保存这组数，每次都去找最小值，把最小值构建结点并使用头插法插入到单链表中。 然后将该值删掉(为简便起见，把值弄成MAX)。 这里使用的是类直接插入的排序方法。 代码实现 #include <stdio.h> #include <stdlib.h> #define MAX 1000000 // 单链表结构体定义 typedef struct node { int val; struct node *next; } n
单向链表4 (10 分)定义单向链表：输入若干个正整数（输入-1为结束标志），要求按输入数据的逆序并输出。
热门推荐
weixin_44115534的博客
05-14 1万+
7-1 单向链表4 (10 分)定义单向链表：输入若干个正整数（输入-1为结束标志），要求按输入数据的逆序并输出。 输入输出示例：括号内为说明 输入样例: 1 2 3 4 5 6 7 -1 输出样例: 7 6 5 4 3 2 1 c++编译器 #include<stdio.h>#include<stdlib.h>typedef struct LNode { int d...
143重排链表的任务分析
最新发布
04-26
143重排链表的任务分析如下： 1. 首先，需要遍历链表，找到链表的中间节点。可以使用快慢指针的方法，快指针每次移动两步，慢指针每次移动一步，当快指针到达链表末尾时，慢指针指向的节点即为中间节点。 2. 将链表...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值