数据结构 ： 单链表 头插入法&尾插入法 及几种常用操作

已于 2022-11-05 17:16:57 修改
阅读量6.7k 收藏 54
点赞数 7
分类专栏： C 文章标签： 数据结构 链表 算法
于 2022-11-05 16:41:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40928870/article/details/127692206
版权

头插入法

在初始化之后，就可以着手开始创建单链表了，单链表的创建分为头插入法和尾插入法两种，两者并无本质上的不同，都是利用指针指向下一个结点元素的方式进行逐个创建，只不过使用头插入法最终得到的结果是逆序的。
如图，为头插法的创建过程：
在这里插入图片描述
该方法从一个空表开始，生成新结点，并将读取到的数据存放到新结点的数据域中，然后将新结点插入到当前链表的表头，即头结点之后。

//初始化单链表，使用头插法建立单链表
LinkedList LinkedListCreatH() {
    Node *L;
    L = (Node *)malloc(sizeof(Node)); //申请头结点空间
    L->next = NULL; //初始化一个空链表
    }
    int x;  //x为链表数据域中的数据
    while(scanf("%d",&x) != EOF) {
        Node *p;
        p = (Node *)malloc(sizeof(Node));  //申请新的结点
        p->data = x;  //结点数据域赋值
        p->next = L->next; //将结点插入到表头L-->|2|-->|1|-->NULL
        L->next = p;
    }
    return L;

// 链表的创建和遍历
link * initLink(){
    link * p=(link*)malloc(sizeof(link));//创建一个头结点
    link * temp=p;//声明一个指针指向头结点，用于遍历链表
    //生成链表
    for (int i=1; i<5; i++) {
        link *a=(link*)malloc(sizeof(link));
        a->elem=i;
        a->next=NULL;
        temp->next=a;
        temp=temp->next;
    }
    return p;
}

尾插入法

在这里插入图片描述
头插法建立单链表的算法虽然简单，但生成的链表中结点的次序和输入数据的顺序不一致。若希望两者次序一致，可采用尾插法。

该方法是将新结点逐个插入到当前链表的表尾上，为此必须增加一个尾指针 r, 使其始终指向当前链表的尾结点，否则就无法正确的表达链表。

//初始化单链表，尾插法建立单链表
LinkedList LinkedListCreatT() {
    Node *L;
    L = (Node *)malloc(sizeof(Node));   //申请头结点空间
    L->next = NULL;                  //初始化一个空链表
    Node *r;
    r = L;                          //r始终指向终端结点，开始时指向头结点
    int x;                         //x为链表数据域中的数据
    while(scanf("%d",&x) != EOF) {
        Node *p;
        p = (Node *)malloc(sizeof(Node));   //申请新的结点
        p->data = x;                     //结点数据域赋值
        r->next = p;            //将结点插入到表头L-->|1|-->|2|-->NULL
        r = p;
    }
    r->next = NULL;
    return L;
}

链表（增删改查/遍历/元素个数）

链表结构体声明：

首先，在创建一个链表之前，我们要先创建一个链表单个节点的结构体，分别包含数据域和指针域，具体实现如下：

typedef struct node{
	int data;               //数据域
	struct node *next;      //指针域（结构体类型指针）
}Node,*Link; //取别名 Node 和 结构体指针类型 Link

单链表的创建：

创建一个带有头结点的链表，虽然不是必须的，但是很方便。

Link create()
{
	Link head = NULL; //初始化Link指针指向null
	head = (Link)malloc(sizeof(Node));//申请新节点
	if(head == NULL)
	{
		printf("动态内存分配失败");
		return NULL; 
	}
	head->data = 0;            //数据域赋初始值
	head->next = NULL;         //指针域赋初始值
	
	return head;
}

单链表的插入：

头插法增加节点：（插入顺序为反向）

void head(Link head,int num)
{
	Link p,pr;
	p = head->next;				//p为头结点的下一个 
	pr = NULL;					//pr为新插入的结点 插在head后p前 
	pr = (Link)malloc(sizeof(Node));
	
	if(pr == NULL)
	{
		printf("动态内存分配失败");
		return ;
	}
	
	pr->data = num;		//给pr数据域赋值 
	
	pr->next = p;		//头插！
	head->next = pr;
	
	return ; 
 }

尾插法增加节点：（插入顺序为正向）

void rear(Link head,int num)
{
	Link p = head;
	Link pr = NULL;		//pr为新增节点
	
	pr = (Link)malloc(sizeof(Node));
	if(pr == NULL)
	{
		printf("动态内存分配失败");
		return ; 
	}
	
	pr->data = num;				//数据域赋值 
	if(head->next == NULL)		//如果头结点下一个为空，就可以直接插入 
	{
		head->next = pr;		//插在头结点后一个 
		pr->next = NULL;		//插完后就指向空结束了 
	} 
	else
	{
		while(p->next != NULL)	//头节点不指向空，就先循环遍历链表找到最后一个再插进去 
		{
			p = p->next;
		}
		p->next = pr;			//尾插！ 
		pr->next = NULL;
	} 
	return； 
}

单链表的删除：

void deletenode(Link head,int n)	//传入链表和要删除的数
{
	Link p = NULL,pr = NULL;	//定义一前一后两个节点
	p = head;
	pr = head->next;
	
	if(head == NULL)
	{
		printf("链表为空，没有可删除的值");
		return ; 
	}
	
	while(pr->data != n && pr->next != NULL)	//没遍历到要删除的值，并且不指空，就接着遍历
	{
		p = pr;		//删除操作，前保存后
		pr = pr->next; 
	}
	
	 //出循环有两种情况：
	 //1.找到要删除的值了
	 //2.整个链表遍历到最后也没找到，
	 //  也就是说这个传入的要删除的值根本不存在链表当中 
	 
	 if(pr->data == n)
	 {
	 	if(pr == head)			//优先考虑，pr为头节点，直接给head保存，最后一起释放pr 
	 	{
	 		head->next = pr->next;
		}
		else
		{
			p->next = pr->next 	//前面p保存后面pr，最后一起释放pr 
		}
		free(pr);
		printf("删除成功！"); 
	 } 
	 else
	 {
	 	printf("未找到要删除的值"); 
	 }
	 
	 return ;
	 
 }

单链表的修改：

void fix(Link head,int m)		//传入链表和要改动的值
{
	Link pr;
	pr = head->next;
	
	int fixnum;
	if(head == NULL)
	{
		printf("链表为空，无可删除的数据");
		return ;
	}
	
	while(pr->next != NULL)		//遍历整个链表
	{
		if(pr->data == m)
		{
			printf("请输入新值：");
			scanf("%d",&fixnum);
			pr->data = fixnum;		//给pr数据域赋新的值
			
			return;					//修改完毕直接结束执行此函数 
		}
		pr = pr->next;			//没找到则一直遍历 
	}
	
	printf("未找到可以修改的值");	//出循环还没找到就是这个值不存在
	
	return; 
	 
 }

单链表的查询：

void search(Link head,int x)	//传入整个链表和要查询的值
{
	Link p;
	p = head;
	if(head == NULL)
	{
		printf("链表为空，无可查询的数据");
		return ; 
	}
	
	p->data = x;
	int searchnode;
	printf("输入带查询的数：");
	scanf("%d",&searchnode);
	
	while(p->data != searchnode && p->next != NULL)	//如果不是查询的值并且指向不为空，就进入循环遍历 
	{
		p = p->next;
	}
	
	//出循环就是两种情况（和删除修改一样）
	if(p->data == searchnode)
	{
		printf("查询结果：%d",searchnode);
		return ;					//找到直接退出函数执行 
	}
	else
	{
		printf("未找到要查询的值");
	}
	
	return ; 
}

链表的陈列（遍历）：

void display(Link head)
{
	Link pr = head->next;
	while(pr != NULL)			//注意陈列打印的条件 
	{
		printf("%d\t",pr->data);
		pr = pr->next; 
	}
	return ;
}

链表的元素个数：

void displaynode(Link head)
{
	Link pr = head->next;
	int count = 0;
	
	while(pr != NULL)
	{
		pr = pr->data;
		cnt++; 
	}
	printf("%d",count);
	
	return ;
}

其他类似操作

遍历单链表（打印，修改）

便利的概念想必大家都不会陌生，即就是从链表的头开始，逐步向后进行每一个元素的访问，这就是遍历，对于遍历操作，我们可以衍生出很多常用的数据操作，比如说查询元素，修改元素，获取元素个数，打印整个链表数据等等。

进行遍历的思路极其简单，只需要建立一个指向链表L的结点，然后沿着链表L逐个向后搜索即可。

对于遍历操作，以下是代码实现：

//便利输出单链表
void printList(LinkedList L){
    Node *p=L->next;
    int i=0;
    while(p){
        printf("第%d个元素的值为:%d\n",++i,p->data);
        p=p->next;
    }
}

对于元素修改操作，以下是代码实现：

//链表内容的修改，再链表中修改值为x的元素变为为k。
LinkedList LinkedListReplace(LinkedList L,int x,int k) {
    Node *p=L->next;
    int i=0;
    while(p){
        if(p->data==x){
            p->data=k;
        }
        p=p->next;
    }
    return L;
}

简单的遍历设计的函数只需要void无参即可，而当我们需要进行元素修等涉及到元素操作时，我们可以设计一个LinkedList类型的函数，使其返回一个修改后的新链表。

以上的操作均用到了遍历的思维，针对于遍历还有非常多的用法供自主设计，请参考后文配套的习题进行练习。

链表插入操作

链表的增加结点操作主要分为查找到第i个位置，将该位置的next指针修改为指向我们新插入的结点，而新插入的结点next指针指向我们i+1个位置的结点。其操作方式可以设置一个前驱结点，利用循环找到第i个位置，再进行插入。

如图，在DATA1和DATA2数据结点之中插入一个NEW_DATA数据结点：

从原来的链表状态
在这里插入图片描述

到新的链表状态：
在这里插入图片描述

//单链表的插入，在链表的第i个位置插入x的元素
  
LinkedList LinkedListInsert(LinkedList L,int i,int x) {
    Node *pre;                      //pre为前驱结点
    pre = L;
    int tempi = 0;
    for (tempi = 1; tempi < i; tempi++) {
        pre = pre->next;                 //查找第i个位置的前驱结点
    }
    Node *p;          //插入的结点为p
    p = (Node *)malloc(sizeof(Node));
    p->data = x;
    p->next = pre->next;
    pre->next = p;
  
    return L;
}

链表删除操作

删除元素要建立一个前驱结点和一个当前结点，当找到了我们需要删除的数据时，直接使用前驱结点跳过要删除的结点指向要删除结点的后一个结点，再将原有的结点通过free函数释放掉。
在这里插入图片描述

//单链表的删除，在链表中删除值为x的元素
  
LinkedList LinkedListDelete(LinkedList L,int x) {
    Node *p,*pre;                   //pre为前驱结点，p为查找的结点。
    p = L->next;
     
    while(p->data != x) {              //查找值为x的元素
        pre = p;
        p = p->next;
    }
    pre->next = p->next;          //删除操作，将其前驱next指向其后继。
    free(p);
     
    return L;
}

完整实现代码

#include <stdio.h>
#include <stdlib.h>
 
//定义结点类型
typedef struct Node {
    int data;           //数据类型，你可以把int型的data换成任意数据类型，包括结构体struct等复合类型
    struct Node *next;          //单链表的指针域
} Node,*LinkedList;
 
//单链表的初始化
LinkedList LinkedListInit() {
    Node *L;
    L = (Node *)malloc(sizeof(Node));   //申请结点空间
    if(L==NULL){    //判断申请空间是否失败
        exit(0);    //如果失败则退出程序
    }
    L->next = NULL;          //将next设置为NULL,初始长度为0的单链表
    return L;
}
 
 
//单链表的建立1，头插法建立单链表
LinkedList LinkedListCreatH() {
    Node *L;
    L = (Node *)malloc(sizeof(Node));   //申请头结点空间
    L->next = NULL;                      //初始化一个空链表
 
    int x;                         //x为链表数据域中的数据
    while(scanf("%d",&x) != EOF) {
        Node *p;
        p = (Node *)malloc(sizeof(Node));   //申请新的结点
        p->data = x;                     //结点数据域赋值
        p->next = L->next;                    //将结点插入到表头L-->|2|-->|1|-->NULL
        L->next = p;
    }
    return L;
}
 
 
//单链表的建立2，尾插法建立单链表
 
LinkedList LinkedListCreatT() {
    Node *L;
    L = (Node *)malloc(sizeof(Node));   //申请头结点空间
    L->next = NULL;                  //初始化一个空链表
    Node *r;
    r = L;                          //r始终指向终端结点，开始时指向头结点
    int x;                         //x为链表数据域中的数据
    while(scanf("%d",&x) != EOF) {
        Node *p;
        p = (Node *)malloc(sizeof(Node));   //申请新的结点
        p->data = x;                     //结点数据域赋值
        r->next = p;                 //将结点插入到表头L-->|1|-->|2|-->NULL
        r = p;
    }
    r->next = NULL;
 
    return L;
}
 
 
//单链表的插入，在链表的第i个位置插入x的元素
 
LinkedList LinkedListInsert(LinkedList L,int i,int x) {
    Node *pre;                      //pre为前驱结点
    pre = L;
    int tempi = 0;
    for (tempi = 1; tempi < i; tempi++) {
        pre = pre->next;                 //查找第i个位置的前驱结点
    }
    Node *p;                                //插入的结点为p
    p = (Node *)malloc(sizeof(Node));
    p->data = x;
    p->next = pre->next;
    pre->next = p;
 
    return L;
}
 
 
//单链表的删除，在链表中删除值为x的元素
 
LinkedList LinkedListDelete(LinkedList L,int x) {
    Node *p,*pre;                   //pre为前驱结点，p为查找的结点。
    p = L->next;
     
    while(p->data != x) {              //查找值为x的元素
        pre = p;
        p = p->next;
    }
    pre->next = p->next;          //删除操作，将其前驱next指向其后继。
    free(p);
     
    return L;
}
 
//链表内容的修改，再链表中修改值为x的元素变为为k。
LinkedList LinkedListReplace(LinkedList L,int x,int k) {
    Node *p=L->next;
    int i=0;
    while(p){
        if(p->data==x){
            p->data=k;
        }
        p=p->next;
    }
    return L;
}
 
 
//便利输出单链表
void printList(LinkedList L){
    Node *p=L->next;
    int i=0;
    while(p){
        printf("第%d个元素的值为:%d\n",++i,p->data);
        p=p->next;
    }
} 
 
int main() {
    //创建 
    LinkedList list;
    printf("请输入单链表的数据：以EOF结尾\n");
    list = LinkedListCreatT();
    //list=LinkedListCreatT();
    printList(list);
     
    //插入 
    int i;
    int x;
    printf("请输入插入数据的位置：");
    scanf("%d",&i);
    printf("请输入插入数据的值：");
    scanf("%d",&x);
    LinkedListInsert(list,i,x);
    printList(list);
     
    //修改
    printf("请输入修改的数据：");
    scanf("%d",&i);
    printf("请输入修改后的值：");
    scanf("%d",&x);
    LinkedListReplace(list,i,x);
    printList(list);
     
    //删除 
    printf("请输入要删除的元素的值：");
    scanf("%d",&x);
    LinkedListDelete(list,x);
    printList(list);
 
    return 0;
}
Michael_chemic
关注
  • 7
    点赞
  • 踩
  • 54
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
链表：头插法与尾插法（简易图解和代码）
花间半盘棋
11-04 3万+
头插法 定义：输入的数据次序生成的链表节点次序相反，例如：按1,2,3顺序进行头插之后，最终排序却变成了3,2,1。简而言之就是逆序插入。 定义图解： 代码图解： 代码：（使用头插法建立单链表） Linklist head_insert(Linklist &L){ //准备工作 LNode *s; // s是指向待插入结点的指针 int x; // 传入结点中data的值 L=(Linklist*)malloc(sizeof(LNode)); // ❤创建L链表, //malloc
数据结构基础——链表
qq_65687767的博客
09-04 2515
数据结构 ——链表
【数据结构】考点十五：广义表的表头和表尾
超越的博客
04-19 905
广义表的表头和表尾描述如下： 表头 。当广义表不为空表时，第一个元素（可能为子表和原子）称为表头。 表尾 。除去表头后，剩余元素组成的广义表称为表尾。 例如，广义表S=(((a)),(b),c,(a),(((d,e)))),其中，表头为第一个元素(((a))，表尾为剩余元素组成的广义表，即((b),c,(a),(((d,e))))。
链表(C语言）
weixin_61196797的博客
04-30 4007
前言 本次我们介绍链表的创建及增，删，改，查。 ` 一、链表是什么？ 首先我们来了解一下线性存储结构。线性存储结构是一种最常见的存储结构。其特点是数据元素之间存在一一对应的关系。线性存储结构又分为两种，即顺序存储结构和链式存储结构。 1.首先，我们来了解一下顺序存储结构。顺序存储的线性表称为顺序表（数组）。其原理是逻辑上相邻的元素在物理位置上也相邻。 我们可以理解为一堆按照一定顺序摆放的书。我们在知道它的排列规律之后就可以通过它的排列规律来找到我们想找到的那本书。我们也可以通过一本一本的去找，来找到我们想要
单链表的插入
Einstein·Jun
11-13 381
单链表的插入
单链表-史上最清晰的尾插法和头插法
程序员阿红的博客
11-23 6644
02.单链表-史上最清晰的尾插法和头插法 1.单链表 链表是一系列的存储数据元素的单元，通过指针(引用)串联起来的，因此每个单元至少有两个域，一个域用于数据元素的存储，另一个域是指向其他单元的指针。 单链表是链表的其中一种基本结构。一个最简单的结点结构如图所示，它是构成单链表的基本结点结构。 在结点中数据域用来存储数据元素，指针域用于指向下一个具有相同结构的结点。 [外链图片转存中…(img-YicPa8n5-1637647195611)] 2.链表定义 链表可增加任意类型数据元素，将其类Lin
基于JAVA的数据结构之单链表操作合
03-25
单链表是一种基础且重要的数据结构，它在计算机科学中被广泛使用，特别是在编程语言如Java中。单链表由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用。这种数据结构允许动态地添加、删除和...
数据结构试验 单链表的基本操作及应用
06-03
在这个"数据结构试验 单链表的基本操作及应用"中，我们可能会涉及以下几个关键知识点： 1. **链表的创建**：首先，我们需要理解如何初始化一个空链表。这通常通过创建一个头节点来实现，头节点的数据域可能为空，但...
图解几种常用数据结构（PPT）
03-20
图解几种常用数据结构（PPT） 在计算机科学中，数据结构是一种组织和存储数据的方式，以便于高效地访问、修改和操作数据。数据结构的选择对程序的性能和可读性产生了巨大的影响。在本文中，我们将图解几种常用的...
单链表的插入删除 遍历等操作
12-05
单链表是数据结构中的一种基础类型，它是由一系列节点（每个节点包含数据和一个指向下一个节点的指针）组成的一维线性结构。在计算机科学中，理解并掌握单链表的插入、删除和遍历等操作是至关重要的，因为它们构成了...
数据结构之单链表操作合集.zip
最新发布
06-17
这个压缩包“数据结构之单链表操作合集.zip”可能包含了关于单链表的各种操作的资源，如创建、插入、删除、遍历等。 在单链表中，每个节点有两部分：数据域和指针域。数据域存储实际的数据，而指针域则存储指向下一...
链表头插法
m0_47170940的博客
03-23 3984
#include <stdio.h> #include <stdlib.h> typedef struct Node{ int date; //数据域 struct Node *next; //存储节点的地址 }LNode,*Linklist; Linklist Creat_list(Linklist head); void Illustrate(Linklist head)//输出每个节点的数据域 函数 { Linklist tem = head;//
单链表的 头插法 尾插法
m0_59342976的博客
08-13 669
一.单链表的插入 从一个空表开始，重复读入数据 生成新结点，将读入数据存放到新结点的数据域中 从最后一个结点开始，依次将各个结点插入到链表的前端 头插法倒位序输入元素 如:L{1,2,3} 输入顺序为 3，2，1 void CreatList_H(LinkList &L, int n){ //n为插入结点数 L = (LinkList)malloc(sizeof(LNode)); L->next = NULL; for(i=n; i>0; i--;..
单链表用头插链表法创建新表、插入元素、打印
weixin_43564529的博客
07-03 60
【代码】单链表用头插链表法创建新表、插入元素、打印。
单链表简单实现
南猿北者博客
10-31 2132
单链表逻辑图：单链表同顺序表一样，都是线性表，除了首尾节点之外，任何一个节点都有自己的前驱和后继；但是单链表每个节点在物理上的地址是不连续的或者说是随机的，也就是说单链表的节点是要一个就开一个，不会过多的开辟空间；这一点正是弥补了顺序表的不足；从上面的逻辑图我们就可以看出，每个节点的类型应该是一样的，节点主要分为数据域和指针域，同时对于一串链表来所，最后一个节点的指针域一定是NULL，以此来标记这是链表的结尾；同时我们只需要知道单链表的头节点，就可以很好的管理整个链表；
链表的两种创建方法——头插法与尾插法
weixin_45728685的博客
03-12 6084
链表创建的两种方法 引言 ​ 首先讲述了我自己在动态实现数据结构的时候遇到的大坑结构体指针问题，随后就是头插法和尾插法的介绍。 结构体指针 引言 ​ 首先需要讲述的是一个让我改了一天半的bug。实际上半天的时候就已经发现了二级指针的问题，但是并没有深究，以为是自己对指针运用不够熟练，就略微重温了一下指针的比较浅层的相关内容，然后第二天的两个程序链栈和链队列都出现了段错误和垃圾值问题，改了半天才发现...
线性表
weixin_44579862的博客
04-28 565
线性表： 定义：线性表是由n个相同数据类型元素a1到an组成的有限序列。 特征：1.在非空的线性表，有且仅有一个开始结点a1，它没有直接前驱，而仅有一个直接a2； 2.有且仅有一个终结点an，它没有直接后继，而仅有一个前趋an-1； 3.其余内部节点ai（2<=i<=n-1）都有且仅有一个直接前趋ai-1和一个直接后继ai+1。 基本运算：1求表长—求线性表中元素个数。 2...
数据结构--广义表
qq_55552561的博客
10-23 1435
任何一个非空的广义表都可以将其分解成表头和表尾两部分，反之，一对确定的表头和表尾可以唯一地确定一个广义表。A=（a,（b，c））：表长度为2的广义表，第一个元素是单个数据a，第二个元素是一个子表（b，c）。C=（a，C）：长度为2递归定义的广义表，C相当于无穷表C=（a,（a,（a,（…B=（A，A，D）：长度为3的广义表，前两个元素为表A，第三个元素为空表D。① 广义表的元素可以是子表，而子表还可以是子表，因此广义表是一个多层的结构。广义表的深度定义为广义表中括弧的重数，是广义表的一种量度。
单链表的头插法与尾插法
sinat_31608641的博客
12-25 1393
头插法
Chapter2 线性表1
08-04
第2章 线性表2.1 线性表2.2 顺序表2.3 单链表2.4 线性链表的其他变形2.5 多项式的表示和运算Data Structures: Linear Li

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Michael_chemic

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值