单链表创建、单链表打印、一级和二级指针做参数、尾插、头插、尾删、头删、查找指定数值位置、指定位置之前插入、指定位置删除、指定位置之后插入、指定位置之后删除等的介绍

于 2024-05-22 21:21:04 发布
阅读量1.3k 收藏 30
点赞数 58
分类专栏： 数据结构 文章标签： c语言 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Farewell_me/article/details/139121369
版权

文章目录

前言

单链表创建、单链表打印、一级和二级指针做参数、尾插、头插、尾删、头删、查找指定数值位置、指定位置之前插入、指定位置删除、指定位置之后插入、指定位置之后删除等的介绍

链表的图示

在这里插入图片描述

一、 单链表节点创建

单链表节点的创建

typedef int SLTDataType;

// 链表节点类型的创建
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;
  • data的类型使用typedef进行重命名，方便修改data的类型
  • 节点的第二个成员为 下一个节点的指针（地址）。

二、 单链表的打印

单链表的打印定义

// 单链表的打印
void SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead;

	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");

}
  • phead是一个指针变量，他存放的是单链表第一个节点的地址，通过 -> 可以访问第一个节点的成员。
  • 将phead存放到变量cur中，防止可能再次使用无法找到phead。
  • 判断若cur不为NULL，则打印当前cur的data。并且将cur置为cur->next（下一个节点的地址）。
  • 判断若cur为NULL，跳出循环。打印NULL。

三、 一级和二级指针做参数

  • 对于一个整形变量，我们若要通过函数来改变这个变量的值。
  • 直接参数是无法实现的，因为形参是实参的一份临时拷贝。如下：
void func(int n)
{
	n = 1;
}

int main()
{
	int a = 0;
	
	func(a);
	printf("%d ", a);// 0
}
  • 若通过函数改变一个整形变量的数值，可以通过传指针（地址），在函数中解引用的方式来实现。如下：
void func1(int* n)
{
	*n = 1;
}

int main()
{
	int a = 0;
	
	func1(&a);
	printf("%d ", a);// 1
}
  • 同理可得，若通过函数改变一个一级指针变量，传入一个一级指针是无法实现的，如下：
void func2(int* n)
{
	n = (int*)malloc(sizeof(int));
}

int main()
{
	int* pa = NULL;
	func2(pa);
	printf("%p", pa);// 0000000000000000
}
  • 同理可得，若要通过函数改变一个一级指针变量，需要传入一个二级指针。
  • 在函数中对二级指针进行解引用来改变一级指针变量。如下：
void func3(int** n)
{
	*n = (int*)malloc(sizeof(int));
}

int main()
{
	int* pa = NULL;
	func3(&pa);
	printf("%p", pa);// 000002733CFA7BC0
}
  • 图解

在这里插入图片描述

四、单链表尾插

单链表尾插定义

  • 由上述一二级指针的关系，可得
  • 若初始状态链表为空（NULL）则尾插需要改变传入的第一个节点的地址。所以需要传入二级指针。
  • 若初始状态链表不为空，则找尾，并进行尾插。
// 创建新节点并初始化的函数
SLTNode* BuyNewNode(SLTDataType x)
{
	// 创建新的节点
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("BuyNewNode()::malloc()");
		return;
	}
	// 初始新节点的数据
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

// 尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = BuyNewNode(x);
	
	// 判断是否单链表头节点地址为空
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		// 找尾
		SLTNode* tail = *pphead;

		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		tail->next = newnode;
	}
}

单链表尾插测试

void SLTest01()
{
	SLTNode* plist = NULL;

	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);

	SLTPrint(plist);
}

效果如下：
在这里插入图片描述

五、单链表头插

单链表头插定义

  • 头插同理也需要传入二级指针。
  • 新节点的next指针指向原来的头节点
  • 头节点又重新指向新的节点。
// 创建新节点并初始化的函数
SLTNode* BuyNewNode(SLTDataType x)
{
	// 创建新的节点
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("BuyNewNode()::malloc()");
		return;
	}
	// 初始新节点的数据
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

// 头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	// 创建新的节点
	SLTNode* newnode = BuyNewNode(x);
	
	newnode->next = *pphead;
	*pphead = newnode;
}

单链表头插测试

void SLTest02()
{
	SLTNode* plist = NULL;
	// 头插
	SLTPushFront(&plist, 1);
	SLTPrint(plist);
	SLTPushFront(&plist, 2);
	SLTPrint(plist);
	SLTPushFront(&plist, 3);
	SLTPrint(plist);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);
}

效果如下：
在这里插入图片描述

六、单链表尾删

单链表尾删定义

  • 找到单链表最后一个节点以及最后一个节点的前一个节点
  • free释放最后一个节点。
  • 并将最后一个节点的前一个节点置为空（NULL）。
// 尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead && *pphead != NULL);

	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tail = *pphead;
		SLTNode* prev = NULL;
		// 找尾
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}

		free(tail);
		tail = NULL;

		prev->next = NULL;
	}
}

单链表尾删测试

void SLTest03()
{
	SLTNode* plist = NULL;

	// 尾插
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);

	SLTPrint(plist);

	// 尾删
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	
}

效果如下：
在这里插入图片描述

五、单链表头删

单链表头删定义

  • 先将链表第二个节点的地址存储
  • 然后释放第一个节点。
  • 最后将链表第一个节点的指着指向存储的第二个节点地址。
// 头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead != NULL);

	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tmp = (*pphead)->next;
		free(*pphead);
		*pphead = tmp;
	}
}

单链表头删测试

void SLTest04()
{
	SLTNode* plist = NULL;

	// 尾插
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);

	SLTPrint(plist);

	// 头删
	SLTPopFront(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
	/*SLTPopFront(&plist);
	SLTPrint(plist);*/

}

效果如下：
在这里插入图片描述

六、单链表查找指定数值位置

查找指定数值位置函数定义

  • 遍历链表，判断每一个节点的data数据是否等于指定数值x
  • 若存在相等，则返回当前节点的地址。
  • 若没有相等，则返回空指针NULL。
// 查找指定数值位置
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	assert(phead);

	SLTNode* cur = phead;

	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;

}

查找指定数值位置函数测试

void SLTest05()
{
	SLTNode* plist = NULL;

	// 尾插
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);

	SLTPrint(plist);

	// 查找指定数值2的位置
	SLTNode* ret = SLTFind(plist, 2);
	if (ret != NULL)
	{
		// 将数值为2的节点数据乘2
		ret->data *= 2;
		SLTPrint(plist);
	}
	else
	{
		printf("没找到!!!\n");
	}	
}

效果如下：
在这里插入图片描述

七、指定位置之前插入

指定位置之前插入函数定义

  • 若pos位置为第一个节点的地址，则直接调用头插
  • 若不是
  • 创建新的节点，找到pos节点之前的节点。
  • 将pos节点之前的节点的next指向新节点。
  • 新节点的next指向pos节点。
// 指定位置之前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);



	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		// 创建新的节点
		SLTNode* newnode = BuyNewNode(x);

		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		prev->next = newnode;
		newnode->next = pos;
	}
	
}

指定位置之前插入函数测试

void SLTest06()
{
	SLTNode* plist = NULL;

	// 尾插
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);

	SLTPrint(plist);

	// 查找指定数值2的位置
	SLTNode* ret = SLTFind(plist, 2);
	
	SLTInsert(&plist, ret, 30);
	SLTPrint(plist);
}

效果如下：
在这里插入图片描述

八、指定位置删除

指定位置删除函数定义

  • 找到指定位置之前的节点（prev）。
  • 将prev的next指向指定位置（pos）的next节点。
/ 指定位置删除
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);

	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}

	prev->next = pos->next;
	free(pos);
}

指定位置删除函数测试

void SLTest07()
{
	SLTNode* plist = NULL;

	// 尾插
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);

	SLTPrint(plist);

	// 查找指定数值2的位置
	SLTNode* ret = SLTFind(plist, 2);

	SLTErase(&plist, ret);

	SLTPrint(plist);
}

效果如下：
在这里插入图片描述

九、指定位置之后插入

指定位置之后插入函数定义

  • 若指定位置pos为最后一个节点，则直接调用尾插
  • 若pos不是最后一个节点
  • 新建一个节点
  • 将新节点的next指向pos的next节点。
  • 将pos的next指向新节点。
// 指定位置之后插入
void SLTInsertAfter(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);


	if (pos == *pphead)
	{
		SLTPushBack(pphead, x);
	}
	else
	{
		// 创建新的节点
		SLTNode* newnode = BuyNewNode(x);


		newnode->next = pos->next;
		pos->next = newnode;
	}

}

指定位置之后插入函数测试

void SLTest08()
{
	SLTNode* plist = NULL;

	// 尾插
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);

	SLTPrint(plist);

	// 查找指定数值2的位置
	SLTNode* ret = SLTFind(plist, 2);

	SLTInsertAfter(&plist, ret, 60);

	SLTPrint(plist);
}

效果如下：
在这里插入图片描述

十、指定位置之后删除

指定位置之后删除函数定义

  • 创建临时变量del存储pos的下一个节点。
  • 将pos的next指向del的next节点。
  • free释放del节点。
  • 将del置为NULL。
// 指定位置之后删除
void SLTEraseAfter(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos && pos->next);


	SLTNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}

指定位置之后删除函数测试

void SLTest09()
{
	SLTNode* plist = NULL;

	// 尾插
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);

	SLTPrint(plist);

	// 查找指定数值2的位置
	SLTNode* ret = SLTFind(plist, 2);

	SLTEraseAfter(&plist, ret);

	SLTPrint(plist);
}

效果如下：
在这里插入图片描述

总结

单链表创建、单链表打印、一级和二级指针做参数、尾插、头插、尾删、头删、查找指定数值位置、指定位置之前插入、指定位置删除、指定位置之后插入、指定位置之后删除等的介绍

Farewell_me
关注
  • 58
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表 创建 头插法 尾插法 就地逆置
05-02
单链表的创建、头插法、尾插法和就地逆置 单链表是链表的一种，它的每个节点只包含一个指针，指向下一个节点。单链表的创建可以通过头插法和尾插法来实现。 头插法 头插法是指在单链表的头部插入新节点的方法。其...
c++头插法和尾插法创建、删除、遍历单链表.zip
最新发布
04-17
本资源位课程设计希望对你有帮助
打印单链表
X__mind的博客
04-18 503
void PrintList(LinkList &L) { LinkList p = L->next; while(p) { cout<<p->data<<" "; p = p->next; } }
单链表打印
六六哥的博客
02-15 899
代码实现 void dumpList(st_dataNode * head){ if(NULL == head){ return; } st_dataNode * p = NULL; printf("========= Dump List %p ===========\n\t", head); p = head; while (NULL != p){ printf("...
03打印单链表
messishow的专栏
04-21 422
/*打印单链表*/ void print(node *head) { node *p; /*新定义一个节点指针*/ int index = 0; /*记录元素号*/ if(head->next == NULL) /*链表为空*/ { printf("Link is empty!\n"); return ; } p = head->next; /*节点指针指向下一个节点*/
用c语言实现单链表的打印,c语言实现单链表
weixin_39719077的博客
05-21 592
/**建立一个链表每个结点包括学号、姓名、性别、年龄。*包括增删改查,排序 交换 反转等功能* */以下是建立在一个学生结构体上的单链表以及单链表各种功能#include#include#includetypedef struct node{int no;int age;char sex[5];char name[20];struct node *next; //指向链表的下一个节点}Node;...
从尾到头打印链表（单链表）
爱生活爱自由
03-20 951
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList 解题思路 看到题目时，第一个反应是用递归，当然暴力求解遍历链表逆向输出也是可行的，但是在遇到此类问题时会显得很麻烦，所以这里我们使用递归的方法。 定义全局链表ArrayList 将链表头节点传入 判断当前节点是否为尾节点的下一节点 如果是 就返回上一层调用函数 并记录上一届点链表值 如果不是 就将下一节点作为参数继续调用...
test3-插入.rar_尾插法_有头插法_链表 插入创建
09-20
链表 插入创建，有头插法，尾插法，入门级的，供实验使用
实现创销添删，头插法和尾插法建表，遍历single-chain-list-master.zip
04-17
实现创销添删，头插法和尾插法建表，遍历single-chain-list-master.zip
单链表的基本操作头插法尾插法创建插入删除遍历
12-08
单链表的基本操作，单链表头插法、尾插法、创建、插入、删除、遍历
2.从尾到头打印单链表
youxia007ya的技术社区
10-23 159
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。 解题思路： /** * 输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。 * 本案例用栈的特性完成反转 */ public class PrintListFromTailToHead { public static void main(String[] args) { ...
【数据结构】单链表(打印链表 创建malloc节点的指针 头插 尾插 头删 尾删 链表的销毁 链表的查找 某个位置去插入 ---- 在pos之前插入 )
m0_68800221的博客
10-22 902
顺序表在头部和中部插入删除数据都是不太合适的，因为要挪动数据时间复杂度为O(N)。扩容过程有消耗，如果需要大一点的空间可能不是原地扩容，拷贝数据，释放旧空间会有不少的消耗。扩容一般是2倍增长，会有一定的空间浪费。现在我们有一种这样的想法：我需要存一个数据，那么就开一块单独的空间去存这个数据，小块小块的开。现在把这些空间开出来，数据存起来后，他们之间如何建立关系呢？可以用指针，前一个节点存储后一个的指针，这个时候它们就链接在一起了。上面说的这种结构就是我们的链表。按需的申请和释放。
从尾到头打印单链表
IT_iverson的博客
12-05 608
问题描述：输入一个链表，从尾到头打印链表每个节点的值。函数接口：vector< int > printListFromTailToHead(ListNode* head)这个题的解法呢有下面几种 1.不根据这个接口写的话就是直接递归从头到尾打印单链表2.根据接口写的话，首先因为给的接口的返回值是一个vector类型的，所以我们可以推断出应该是将链表中的元素从尾到头放在vector中，然后
剑指offer 6：从尾到头打印单链表
weixin_47382783的博客
11-07 100
题目描述： 输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组返回）。 如输入{1,2,3}的链表如下图： 返回一个数组为[3,2,1] 0 <= 链表长度 <= 10000 示例1 输入：{1,2,3} 返回值：[3,2,1] 示例2 输入：{67,0,24,58} 返回值：[58,24,0,67] 解法一：辅助空间 思路： 遍历链表，将节点值存储到 list 中，然后调用 Collections.reverse() 函数反转 lis.
创建单链表 打印单链表 插入删除节点 查找功能
绿色水杯
03-21 555
代码： #include<stdio.h> #include<stdlib.h> #define OK 1 #define FALSE 0 typedef int Status; typedef float ElemType; typedef struct LNode { ElemType data; struct LNode *next; } LNode,* LinkList; LinkList s,r,P; Status i; //创建单链表 void CreatList
数据结构4.4从尾到头打印单链表
weixin_43899452的博客
07-13 265
分析： **方式1：**单链表反转后再遍历（破坏了单链表的结构） **方式2：**利用栈的数据结构，将各个节点压入栈中，然后利用栈的先进后出的结构实现逆序打印。 使用方式2的方法： 测试：
【单链表经典面试题解析一】从尾到头打印单链表
sofia_m的博客
10-15 484
从尾到头打印单链表，我们可以
链表逆置和从尾到头打印单链表
Keep Fighting All The Time
05-16 1774
&amp;amp;nbsp; &amp;amp;nbsp; &amp;amp;nbsp; &amp;amp;nbsp; 链表的逆置和链表从尾到头打印是两个不同的概念，链表的逆置就是将链表（a1,a2,a3…an）转化为（an，a（n-1),..a1），链表结构会发生改变；而从尾到头打印链表是将链表中的元素逆序打印，即从尾结点开始依次打印，链表的结构不发生改变。 &amp;amp;nbsp; &amp;amp;nbsp; &amp;amp;nbsp
用头插法和尾插法创建单链表
03-25
A： 头插法创建单链表的步骤如下： 1. 新建一个头结点，其指针域为空。 2. 依次读入数据，新建一个结点，并将其插入到链表的头部。 代码如下： ``` #include <stdio.h> #include <stdlib.h> typedef struct ListNode { int val; struct ListNode *next; } ListNode; ListNode* createList() { ListNode *head = (ListNode*)malloc(sizeof(ListNode)); head->next = NULL; // 初始化头结点 int x; while (scanf("%d", &x) != EOF) { ListNode *newNode = (ListNode*)malloc(sizeof(ListNode)); newNode->val = x; newNode->next = head->next; head->next = newNode; } return head; } int main() { ListNode *head = createList(); head = head->next; // 链表头结点包含无用信息，需要去掉 while (head != NULL) { printf("%d ", head->val); head = head->next; } return 0; } ``` 尾插法创建单链表的步骤如下： 1. 新建一个头结点，其指针域为空。 2. 定义一个指针p指向头结点。 3. 依次读入数据，每读入一个数据新建一个结点，并将其插入到链表的尾部。插入完成后，将p指向新建的结点。 代码如下： ``` ListNode* createList() { ListNode *head = (ListNode*)malloc(sizeof(ListNode)); head->next = NULL; // 初始化头结点 ListNode *p = head; // 初始指向头结点 int x; while (scanf("%d", &x) != EOF) { ListNode *newNode = (ListNode*)malloc(sizeof(ListNode)); newNode->val = x; newNode->next = NULL; // 将新结点的指针域设为空 // 将新结点插入到链表尾部 p->next = newNode; p = p->next; // p指向新结点 } return head; } ``` 其中，scanf("%d", &x) != EOF 表示当未到达文件结束符时循环读入整数。在Windows命令行下, 文件结束符可以通过按 Ctrl+Z 或 F6 来输入。在Linux系统下，文件结束符可以通过按 Ctrl+D 来输入。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值