链表 P309----P316）（单向链表的建立与输出，插入和删除）

最新推荐文章于 2022-01-06 11:56:51 发布
置顶 最新推荐文章于 2022-01-06 11:56:51 发布
阅读量262 收藏 1
点赞数 2
分类专栏： 谭C 奇怪的问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45651829/article/details/103542834
版权

采用的时谭c上面的例题：
输入一系列学生的成绩，规定学生的学号不为0，按照学号 成绩的顺序输入数据 要求用函数完成传建链表和输出链表的操作
代码：（自闭了好一会二才看懂书上的代码）
（复制到DEV C++里面，主要看注释）

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
//#define NULL 0 程序中就被宏定义了 
#define LEN sizeof(struct student)
struct student{//表明链表中的每个成员都应该长这个样子 
	long num;
	float score;
	struct student *next;//用来存放下一个节点的地址 
};
int n;//计数器用来判断是否为头指针,也可以用来计数人数 
//这是个用来创建链表的函数 
struct student *create(void)//这是一个名叫create的操作型函数,它的返回值的类型是struct student的指针类型,其实就是链表的头指针 
{
	struct student *Head;
	struct student *p1,*p2;
	n = 0;
	//void *malloc(unsigned int size)这是一个返回值为指针的函数,会返回所分配区域的第一个字节的地址即开头的位置
	//但是返回的指针为不指向任何类型的数据的指针 (如果分配内存不成功就会返回NULL指针)
	//强制将返回的指针转化为struct *student 类型的指针,即指向某个结构体的指针，才可以赋给相同类型的p1和p2 
	p1 = p2 = (struct student*)malloc(LEN);//LEN即为分配的内存的长度,且这部分的内存空间连续 ,p1和p2均有了地址，相当于此时的p1和p2就是两个结构体
	//虽然p1和p2指向的那一块内存没有按照成员列表分割为一块一块的但是通过结构体指针的成员来分别指向这块内存的不同区域 
	//p1和p2均为指向struct studet类型的指针，且分配好了地址 ，且均指向这块区域 
	scanf("%ld %f",&p1 -> num,&p2 -> score);//因此可以这样直接向p1和p2里面读入数据 
	Head = NULL;//将Head指向空 
	//while外面的区域其实就相当于将头指针指向的区域孤立出来 
	while(p1 -> num != 0)//只要输入给无名区域的num的值不是0 
	{
		
		
		n = n + 1;//则节点数加一 
		
		
		if(n == 1) Head = p1;//如果这是第一个节点，就把头指针指向这块区域 
		
		
		else p2 -> next = p1;//如果不是第一个节点，就将p2的next指向在上一个循环里面建立的p1所指向的新创建的结构体区域 
		
		
		p2 = p1;//p2再次指向和p1相同的区域,存放这块区域的地址,因为p1马上要指向另一块新创建的区域,对于头节点的情况，这句话其实是不起作用的 
		p1 = (struct student *)malloc(LEN);//p1指向一块新创建的长度为结构体长度的另一块无名区域，p1成为一个新的结构体 
		scanf("%d %f",&p1 -> num,&p1 -> score);//向以后的节点重复性读入数据	 
	} 
	p2 -> next = NULL;//如果跳出循环，则该链表完成建立，将最后一个节点的next成员指向NULL 
	return (Head);//返回头指针Head 
}
//现在来写输出链表的函数
void print(struct student * head)
{
	struct student * p;
	printf("\nNow These %d records are : \n",n);
	p = head;
	if(head != NULL)//只要头指针不指向空，即链表非空就执行输出链表的操作 
	{
		do
		{
			printf("%ld %5.1f\n",p -> num,p -> score);
			p = p -> next;//每次输出后就把p指向下个节点 
		}while(p != NULL);//一直进行到最后一个节点时，其next指向空,结束输出 
	}
 } 
int main(void)
{
	struct student *pt;
	pt = create();
	print(pt); 
}

用图来解释p1和p2的移动轨迹：
在这里插入图片描述
添加在链表内删除指定节点和插入节点的函数：
1.删除指定的节点
代码：

struct student *del(struct student *p1,long long int Num)//num就是待删除节点内的成员的数值 
{
	struct student *p1,*p2;
	if(head == NULL){
		printf("\n list null! WDNMD \n");
		goto end ;
	}
	p1 = head ;
	while(Num != p1 -> num && p1 -> next !=NULL)//遍历寻找待删除的节点	
	{
		p2 = p1 ;//存放p1上一个节点的地址，因为p1马上就要指向此处p1所指向的下一个结构体 
		p1 = p1 -> next ;//同上的解释 
	}
	if(Num == p1 -> num)//找到待删除的节点p1 
	{
		if(p1 == head)
		{
			head = p1 -> next ;//如果待删除的节点就是头指针指向的节点，就把头指针向后移动一个节点即可	
		}else{
		 //如果待删除的节点不是头节点，就分开讨论 
		 p2 -> next = p1 -> next ;
		 //p2为p1的上一个节点，把它指向p1的下一个节点，以后对该链表的操作就会跳过p1，其实并没有将p1在内存中删除
		 //但还是相当于达成删除的目的 
		 printf("delete :%d\n",Num) ;
		 n = n - 1 ;//总的元素数目减一  
		} 
	}else{
		printf("%ld has not been found\n",Num);
		end : return (head) ;
	} 
}

2.在链表中插入节点的操作:

struct *insert(struct student *head,struct student *stud)//stud为待插入的节点 ，且要插入到一个比这个元素小的链表节点前 
{
	 struct student *p1,*p2,*p0 ; 
	 p1 = head ;
	 p0 = stud ;
	 if(head == NULL)//如果链表最开始就为空的状态 
	 {
	 	{
	 		head = p0 ;//head就指向p0，相当于向链表中添加一个新的元素 
			p0 -> next = NULL;//head以后再无元素，则其next指向空 NULL 
		}
	 }
	 else//如果链表最开始就非空 
	 {
	    while(((p0 -> num)>(p1 -> num))&&(p1 -> next != NULL))//即要求待插入节点的成员的值要大于其之前的节点的成员的值，
															  //小于其后节点的成员的值，且p1后面任然有链表元素存在 
	  {
	  	p2 = p1 ;//暂存p1上一个节点的地址，因为p1马上要指向其后的一个节点 
	  	p1 = p1 -> next;//将p1指向p1之后的一个节点 
	  }	
	 }
	 if(p0 -> num <= p1 -> num)//待插入节点的值小于等于其后一个节点的值 
	 {
	 	if(p1 == head)//如果p1是头指针,说明待插入节点应该在头指针之前插入 
	 	{
	 		head = p0;//头指针改为p0 
	 		p0 -next = p1;//p0的下个节点指向老的头指针 
		}
		else if(p1 -> next != NULL)//如果p1之后还有链表元素，即p1不是指向链表的末尾 
	 	{
	 		p2 -> next = p0;//p2是p1上一个节点的地址，其寻找指向待插入节点 
	 		p0 -> next = p1;//待插入节点的下一个节点指向现在的p1，完成在p1之前插入一个节点 
	 	}
	 	else//此时p1指向的就是链表的末尾，则待插入的节点应该在链表的末尾插入 
	 	{
	 		p1 -> next = p0;//则p1指向待插入的节点 
	 		p0 -> next = NULL;//待插入节点的下一个节点就指向NULL，现在的待插入节点成为新的链表的末尾 
	 	}
	 }
	 n = n + 1;//链表元素的总数加一 
	 return (head);//返回头指针的地址 
}

删除和插入的这两个函数并没有实践，可能存在错误
实践代码：
为了确保链表的头节点可以被删掉，应该把删除节点的函数的类型定义为返回值为结构体指针的类型，否则头结点改变后，void类型不能返回新的头节点。

//rewrite the lianbiao
#include<bits/stdc++.h>
#define LEN sizeof(struct node)
using namespace std;
struct node{
	int num;
	float score;
	struct node *next = NULL;
};
int n;
struct node *create_List(void)
{
	struct node *newnode = NULL,*fomernode = NULL,*Head = NULL;
	n = 0;
	newnode = fomernode = (struct node*)malloc(LEN);	
	scanf("%d %f",&newnode->num,&newnode->score);
	while(newnode->num!=0)
	{
		n = n + 1;
		if(n == 1)
		{
			Head = newnode;
		}
		else
		{
			fomernode->next = newnode;
		}
		fomernode = newnode;
		newnode = (struct node*)malloc(LEN);
		scanf("%d %f",&newnode->num,&newnode->score);
	}
	fomernode->next =NULL;
	return Head;
}
void print_List(struct node *head)
{
	struct node *p;
	printf("These records are as follows:\n");
	p = head;
	if(head == NULL)
	{
		printf("NULL List error\n");
	}
	else
	{
		while(p!=NULL)
		{
			printf("%d %f\n",p->num,p->score);
			p = p->next;
		}
	}
}
struct node *delete_Node(struct node *head,int num)
{
	int n=0;
	struct node *p = head;
	struct node *fomernode;
	while(p!=NULL)
	{
		n++;
		if(p->num == num)
		{
			if(n==1)
			{
				head = head->next;
				goto end;
			}
			else
			fomernode->next = p->next;
			goto end;
		}
		else
		{
			fomernode = p;
			p = p->next;
		}
	}
	printf("NOT the number error \n");
	end: return head;
}
struct node* add_Node(struct node *head,int num,struct node *add_one) 
{
	struct node *p=head;
	struct node *former; 
	int N = 0;
	while(p != NULL)
	{
		N++;
		if(p->num==num)
		{
			if(n==1)
			{
				add_one->next = head;
				head->next = add_one;
				goto end;
			}
			else if(p->next==NULL)
			{
				p->next = add_one;
				add_one->next =NULL;
				goto end;
			}
			else
			{
				add_one->next = p->next;
				p->next = add_one;
				goto end;
			}
		}
		else
		{
			former = p;
			p = p->next; 
		}
	}
	printf("NOT this number error\n");
	end: return head;
}
int main(void)
{
	struct node *pt;
	pt = create_List();
	print_List(pt);
	int  num;
	scanf("%d",&num);
	pt = delete_Node(pt,num);
	print_List(pt);
	int Num;
	scanf("%d",&Num);
	struct node adding_one;
	scanf("%d %f",&adding_one.num,&adding_one.score);
	pt = add_Node(pt,Num,&adding_one);
	print_List(pt);
	return 0;
}

删除和添加的片段函数的确是存在一点问题，重在理解思想，光背住板子是没有益处的

其实按照正规的要求，头结点不应该存放数据，其只能存放下一个节点的地址，否则在删除节点的时候会有很多麻烦

#include<bits/stdc++.h>
#define LEN sizeof(struct node)
using namespace std;

struct node
{
	int numbe;
	float score;
	struct node *next;	
};

int n = 0; 

struct node *create_list(void)
{
	struct node *newnode = NULL,*formernode = NULL,*head = NULL;
	newnode = (struct node*)malloc(LEN);
	head = newnode;
	newnode =(struct node*)malloc(LEN);
	scanf("%d %f",&newnode->numbe,&newnode->score);
	while(newnode->numbe!=0)
	{
		n++;
		if(n==1)
		{
			head->next = newnode;
		}
		else
		{
			formernode->next = newnode;
		}
		formernode = newnode;
		newnode = (struct node*)malloc(LEN);
		scanf("%d %f",&newnode->numbe,&newnode->score);
	}
	formernode->next=NULL;
	return head;
}

void print_list(struct node *head)
{
	struct node *p = head->next;
	if(p == NULL)
	{
		printf("The list is NULL\n");
	} 
	else
	{
		while(p!=NULL)
		{
			printf("%d %f\n",p->numbe,p->score);
			p=p->next;
		}
	}
}

int main(void)
{
	struct node *pt;
	pt = create_list();
	//printf("%d %f\n",pt->next->next->numbe,pt->next->next->score);
	printf("END PHASE 1\n");
	print_list(pt);
}

尝试写了一下双向链表（不太清楚定义，就多加了一个节点指向前一个节点）
代码：

//try build a double head list 
#include<bits/stdc++.h>
#define LEN sizeof(struct node)
using namespace std;
struct node//建立结构体类型和声明链表中成员的模板 
{ 
	int number;
	float score;
	struct node *next;
	struct node *before;
};
int n = 0;
struct node *create_List(void)//建立链表的函数 
{
	struct node *newnode = NULL,*formernode = NULL;
	struct node *head = NULL;
	newnode = (struct node*)malloc(LEN);
	formernode = newnode;
	scanf("%d %f",&newnode->number,&newnode->score);
	while(newnode->number!=0)
	{
		n++;
		if(n==1)
		{
			head = newnode;
			head->before = NULL;
		}
		else
		{
			formernode->next = newnode;
			newnode->before = formernode;
		}
		formernode = newnode;
		//newnode->before = formernode;指向前一个节点的指针如果在这里，formernode已经变成了现在输入的新节点，
		//则before还是指向现在的新节点，没有意义 
		newnode = (struct node*)malloc(LEN);
		scanf("%d %f",&newnode->number,&newnode->score);
	}
	formernode->next = NULL;
	return head;
}
void print_List(struct node *head)
{
	struct node *p = head;
	if(p==NULL)
	{
		printf("The list is empty\n");
	}
	else
	{
			while( p!= NULL)
		{
			printf("%d %f ",p->number,p->score);
			if(p->before!=NULL)
			{
				printf("and the date bofore is:%d %f\n",p->before->number,p->before->score);
			}
			else
			{
				printf("and the date bofore is NULL\n");
			}
			p = p->next;
		}
	}
	return ;	
}
int main(void)
{
	struct node *pt;
	pt = create_List();
	print_List(pt);
	return 0;
}

运行后的效果：
在这里插入图片描述

氯的平方
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构c语言版单链表的创建和输出
06-08
（1）键盘输入n，建立长度为n的单链表并输出； （2）键盘输入x。在单链表中查找值为x的结点并删除，最后输出链表。
逆序输出单向链表-Java 版本
最新发布
04-26
附件是逆序输出单向链表_Java 版本源码，代码首先定义了一个Node类来表示链表的节点，然后定义了一个LinkedList类来表示单链表，并提供了添加节点、打印链表和逆序链表的方法。最后，在Main类中创建了一个链表实例，...
单向循环链表的创建与输出
qq_42727102的博客
04-01 1018
//单向循环链表即为无头无尾 //①尾结点的指针域指向头结点 //②设置一个尾指针更加高效 //③在插入和删除算法上要遵守单向链表的特点 //创建单向循环链表 ElemSN *Createlink(int a[]) { ElemSN *h,*t,*p; h=NULL; for(int i=0;i<N;i++){//为新结点分配单元 p=(ElemSN *)malloc(sizeof...
单链表之链表的创建与输出
qq_49729886的博客
11-16 2310
文章目录一、链表是什么？二、使用步骤1.定义结构体类型2.创建及输出动态单链表1.尾插法无头单链表❤2.尾插法有头单链表3.头插法无头单链表4.头插法有头单链表 一、链表是什么？ 官方解释: 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 二、使用步骤 1.定义结构体类型 代码如下： struct node { int num; struct node* next; }; 2.创建及
7-5 单向链表的创建与输出
aixuexi8869的博客
01-06 9371
7-5 单向链表的创建与输出 本题目要求补充两个函数，实现如下功能： 输入若干个正整数，以-1结束，采取向链表中添加节点的方式来建立一个单链表，并输出这个单链表。 向链表尾部添加节点函数： Link AppendNode(Link head,int data); 其中Link结构定义如下： typedef struct link { int data; struct link *next; }*Link; head：链表头指针，如果head为NULL，则会新建头节点 dat
单链表的建立与输出
菜鸟
05-18 5321
链表可以用头插法建立，也可以用尾插法建立。然而头插法虽然操作简单一点，顺序却与输入顺序相反，尾插法虽然操作复杂一点，但是顺序却与输入顺序一致，所以建议使用尾插法。 一、头插法建立链表 1、不用函数 代码： #include #include typedef struct linknode { int data; linknode *next; } Node,*Linkl
链表-正序建立链表-正序建立
02-10
建立正序链表链表——正序建立
C语言实现单向动态链表的创建和输出
西叶胡杨的博客
09-25 645
C语言](这里写自义目录标题) 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高
链表介绍（一）之创建单向动态链表及输出单向链表内容
liitdar的博客
07-09 922
链表是一个数据的集合，其中每个元素包含下一个元素的地址，即每个元素包含两部分内容：数据（data）和链（link）。数据部分包含可用的信息；链则将数据连在一起，它包含一个指向链表中下一个元素的指针（地址）。说明：链表中的元素习惯上被称为节点（node）。链表是动态地进行存储分配的一种数据结构，与数组相比，链表可以根据需要动态地开辟内存单元，并且链表中的节点在内存中是非连续的。
链表的创建和输出链表的创建和输出
05-23
链表的创建和输出链表的创建和输出链表的创建和输出链表的创建和输出链表的创建和输出链表的创建和输出链表的创建和输出链表的创建和输出
链表的创建与输出
baymin_dly的博客
07-19 621
创建两个学生链表，含有姓名，年龄的信息，一个链表存放男生，一个链表存放女生 并且合并这两个链表。 #include #include #define LEN sizeof (struct student) struct student { char name[100]; int age; struct student *next; };
单向列表设计，单向链表的增加节点、删除节点、查询节点、打印链表
jakezhang1990的专栏
08-26 455
java首先单向链表，实现链表的末尾增加，删除节点，查询节点，打印链表。 简短精悍的设计，记录一下，多多学习这样的设计思路。 class Link{ class Node{ private String data;//值 private Node next;//下一个节点的引用 public Node(String data){ this.data=data; } pr...
创建单向链表、添加节点、删除一个节点、删除重复节点操作（Python）
m0_58475958的博客
06-28 475
创建单向链表、添加节点、删除一个节点、删除重复节点操作（Python） # 定义节点类 class SingleNode(object): # 初始化属性 def __init__(self, item): # 数据域 self.item = item # 链接域 self.next = None # 定义链表类 class SingleLinkList(object): # 初始化属性（头节点指向node，node默认为None） def __init__(self, node=
对带头节点的单链表进行建立，增加，删除，修改
Kuches的博客
03-05 553
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、使用尾插法建立单链表1.方法理解2.代码示例二、头插法建立单链表1.方法理解2.代码示例二、头插法建立单链表总结 前言 对带头节点单链表进行一些基础操作 一、使用尾插法建立单链表 1.方法理解 使用尾插法建立单链，主要是要建立两个节点，一个节点用于存储当前输入数据，另外一个节点要始终指向当前链表的尾部即尾节点。使用尾插法建立链表的数据顺序是键入的数据顺序。 2.代码示例 #include<stdio.h>
链表
weixin_46102920的博客
09-05 125
这里写目录标题链表介绍单链表的应用实例添加一：直接添加到链表的尾部添加二：根据排名插入到指定位置删除节点 链表介绍 链表是有序的链表，在内存中存储如下图 链表是以节点的方式来存储，是链式存储 每个节点包括 data域（存值）和 next 域（指向下一个节点） 链表的各个节点不一定是连续存储 链表分为带头节点的链表和不带头结点的链表 单链表的应用实例 使用带头结点的单向链表实现水浒英雄排行榜管理，完成对英雄人物的增删改查操作 添加一：直接添加到链表的尾部 添加二：根据排名插入到指定位置 删除节
【数据结构】链表基本操作（个人总结版）有问题望各位指出
BaiYZ的Blog
11-21 516
** 总结一下链表常用操作，写的不是很好，有需要朋友看看，注释按自己理解注明了 /*有头节点的链表（头节点无数据） * @Description: 链表的 1.建立（头插，尾插）2.输出第n个节点 3.删除第n个节点，并保存值 4.插入元素到第n个节点 5.删除所哟节点 6.输出所有节点 * @Version: 1.0 * @Author: BaiYiZhuo * @Date: 2020-11-21 17:31:36 * @LastEditTime: 2020-11-21 22:59:58 */
程序设计与问题求解实验报告六
young的博客
11-12 2242
程序设计与问题求解实验报告六 ——结构体与链表程序设计 文章目录程序设计与问题求解实验报告六——结构体与链表程序设计前言一、实验目的二、实验内容和步骤1.修改错误程序——结构体相关编程2.修改错误程序——链表相关编程3.简单有序链表的创建和查询修改三、实验总结 前言 提示：以下是本篇文章正文内容，下面案例可供参考 一、实验目的 1.掌握结构化数据的编程使用； 2.掌握指针与内存地址的关系； 3.掌握通过指针动态申请和释放内存的编程方法； 4.掌握单向链表的基本操作。 二、实验内容和步骤 1.修改错误
C语言单链表的创建、输出、插入结点、删除结点
YHxiaohao的博客
04-17 8876
链表对于C语言的学习者来说是一大难点，但链表又是学好数据结构的基础。在此，对单链表的创建、输出、结点的插入、结点的删除进行简要介绍。1、首先定义一个结构体数组#define LEN sizeof(struct student) struct student { int num; char name[20]; float score; struct student *next; }; int...
7-122 单向链表的创建与输出
07-12
要创建一个单向链表，你可以定义一个节点类，每个节点包含一个数据项和指向下一个节点的指针。然后，通过不断创建新的节点并将其链接到链表的末尾来构建链表。以下是一个示例代码，演示了如何创建并输出一个单向链表： ```python # 定义节点类 class ListNode: def __init__(self, data): self.data = data self.next = None # 创建链表 def createLinkedList(values): if not values: return None head = ListNode(values[0]) current = head for value in values[1:]: new_node = ListNode(value) current.next = new_node current = new_node return head # 输出链表 def printLinkedList(head): current = head while current: print(current.data, end=" ") current = current.next print() # 测试代码 values = [7, -122] head = createLinkedList(values) printLinkedList(head) ``` 这段代码中，我们首先定义了一个节点类`ListNode`，其中包含数据项`data`和指向下一个节点的指针`next`。然后，我们使用`createLinkedList`函数根据给定的数值列表创建链表。在这个函数中，我们遍历数值列表，创建新的节点，并将其链接到链表的末尾。最后，我们使用`printLinkedList`函数输出链表的所有数据项。在这个函数中，我们遍历链表，并打印每个节点的数据项。 输出结果将为：`7 -122`，表示链表中的两个节点数据项。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值