单链表（无头单向）的操作实现（C）

已于 2022-05-11 22:36:52 修改
阅读量310 收藏
点赞数 4
分类专栏： C/C++小项目 文章标签： 链表 c语言 散列表
于 2022-05-11 22:34:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lihua777/article/details/124720794
版权

二级指针是为了 修改指针所指向的内容，而不返回参数，直接在原地址上修改

SList.h

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

SLTNode* BuySListNode(SLTDataType x);
void SListPrint(SLTNode* phead);
void SListPushBack(SLTNode** pphead, SLTDataType x);
void SListPushFront(SLTNode** pphead, SLTDataType x);
void SListPopBack(SLTNode** pphead);
void SListPopFront(SLTNode** pphead);
SLTNode* SListFind(SLTNode* phead, SLTDataType x);

// 在pos位置之前插入
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
// 删除pos位置的值
void SListErase(SLTNode** pphead, SLTNode* pos);

SList.c

(1)
#include "SList.h"

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

SLTNode* BuySListNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	assert(newnode);
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySListNode(x);

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

		tail->next = newnode;
	}
}

void SListPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = BuySListNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);

	// 1、只有一个节点
	// 2、多个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		/*SLTNode* tailPrev = NULL;
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tailPrev = tail;
			tail = tail->next;
		}
		free(tail);
		tailPrev->next = NULL;*/
		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}	
}

void SListPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead != NULL);
	//if (*pphead == NULL)
	//	return;

	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
			return cur;

		cur = cur->next;
	}

	return NULL;
}


void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pos);
	assert(pphead);

	// 头插
	if (pos == *pphead)
	{
		SListPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		SLTNode* newnode = BuySListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

// 删除pos位置的值
void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);

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

		prev->next = pos->next;

		free(pos);
		pos = NULL;
	}
}


// 单链表在pos位置之后插入x
void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	/*SLTNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;*/

	// 不在乎链接顺序
	SLTNode* newnode = BuySListNode(x);
	SLTNode* next = pos->next;
	// pos newnode next
	pos->next = newnode;
	newnode->next = next;
}

// 分析思考为什么不删除pos位置？
void SListEraseAfter(SLTNode* pos)
{
	assert(pos);

	if (pos->next == NULL)
		return;

	SLTNode* del = pos->next;
	//pos->next = pos->next->next;
	pos->next = del->next;

	free(del);
	del = NULL;
}

 

(2)
#include "SList.h"
 
SListNode* BuySListNode(SLTDateType x)
{
	SListNode* node = (SListNode*)malloc(sizeof(SListNode));
	node->data = x;
	node->next = NULL;
 
	return node;
}
 
void SListPrint(SListNode* plist)
{
	SListNode* cur = plist;
	while (cur)
	//while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}
 
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	SListNode* newnode = BuySListNode(x);
	if (*pplist == NULL)
	{
		*pplist = newnode;
	}
	else
	{
		SListNode* tail = *pplist;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
 
		tail->next = newnode;
	}
}
 
void SListPopBack(SListNode** pplist)
{
	SListNode* prev = NULL;
	SListNode* tail = *pplist;
	// 1.空、只有一个节点
	// 2.两个及以上的节点
	if (tail == NULL || tail->next == NULL)
	{
		free(tail);
		*pplist = NULL;
	}
	else
	{
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
 
		free(tail);
		tail = NULL;
 
		prev->next = NULL;
	}
}
 
 
void SListPushFront(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
 
	// 1.空
	// 2.非空
	SListNode* newnode = BuySListNode(x);
	if (*pplist == NULL)
	{
		*pplist = newnode;
	}
	else
	{
		newnode->next = *pplist;
		*pplist = newnode;
	}
}
 
void SListPopFront(SListNode** pplist)
{
	// 1.空
	// 2.一个
	// 3.两个及以上
	SListNode* first = *pplist;
	if (first == NULL)
	{
		return;
	}
	else if (first->next == NULL)
	{
		free(first);
		*pplist = NULL;
	}
	else
	{
		SListNode* next = first->next;
		free(first);
		*pplist = next;
	}
}
 
SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	SListNode* cur = plist;
	while (cur)
	{
		if (cur->data == x)
			return cur;
 
		cur = cur->next;
	}
 
	return NULL;
}
 
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	assert(pos);
	SListNode* next = pos->next;
	// pos newnode next
	SListNode* newnode = BuySListNode(x);
	pos->next = newnode;
	newnode->next = next;
}
 
void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	// pos next nextnext
	SListNode* next = pos->next;
 
	if (next != NULL)
	{
		SListNode* nextnext = next->next;
		free(next);
		pos->next = nextnext;
	}
}

test.c

#include "SList.h"

void TestSList1()
{
	//struct SListNode* 
	SLTNode* n1 = (SLTNode*)malloc(sizeof(SLTNode));
	assert(n1);
	SLTNode* n2 = (SLTNode*)malloc(sizeof(SLTNode));
	assert(n2);
	SLTNode* n3 = (SLTNode*)malloc(sizeof(SLTNode));
	assert(n3);
	SLTNode* n4 = (SLTNode*)malloc(sizeof(SLTNode));
	assert(n4);

	n1->data = 1;
	n2->data = 2;
	n3->data = 3;
	n4->data = 4;

	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = NULL;

	SLTNode* plist = n1;
	SListPrint(plist);

	SListPushBack(&plist, 5);
	SListPushBack(&plist, 6);
	SListPushBack(&plist, 7);
	SListPushBack(&plist, 8);
	SListPrint(plist);
}

void TestSList2()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPushBack(&plist, 5);
	SListPushBack(&plist, 6);
	SListPushBack(&plist, 7);
	SListPrint(plist);

	SListPushFront(&plist, 0);
	SListPrint(plist);
}

void TestSList3()
{
	SLTNode* plist = NULL;
	SListPushFront(&plist, 0);
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 4);
	SListPrint(plist);

	SListPopFront(&plist);
	SListPopFront(&plist);
	SListPopFront(&plist);
	SListPopFront(&plist);
	SListPopFront(&plist);
	//SListPopFront(&plist);
	SListPrint(plist);
}

void TestSList4()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);

	SListPrint(plist);

	SListPopBack(&plist);
	SListPrint(plist);

	SListPopBack(&plist);
	SListPrint(plist);

	SListPopBack(&plist);
	SListPrint(plist);

	SListPopBack(&plist);
	SListPrint(plist);

	//SListPopBack(&plist);
	//SListPrint(plist);
}

void TestSList5()
{
	SLTNode* plist = NULL;
	SListPrint(plist);

	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPrint(plist);

	SLTNode* ret = SListFind(plist, 3);
	if (ret)
	{
		printf("找到了\n");
		ret->data = 30;
	}
	SListPrint(plist);


	SLTNode* pos = SListFind(plist, 4);
	if (pos)
	{
		SListInsert(&plist, pos, 40);
	}
	SListPrint(plist);

	//SListPushBack(NULL, 1);

	//SListInsert(&plist, NULL, 40);
	//SListPrint(plist);

	pos = SListFind(plist, 4);
	if (pos)
	{
		SListErase(&plist, pos);
	}
	SListPrint(plist);
}
//
//int main()
//{
//	TestSList5();
//
//	return 0;
//}

//void f1(int* p)
//{
//	*p = 1;
//}
//
void f2(int* p)
{
	int* px = (int*)malloc(sizeof(int));
	assert(px);
	p = px;
}
//
//void f2(int** pp)
//{
//	int* px = (int*)malloc(sizeof(int));
//	assert(px);
//	*pp = px;
//}
//
//int main()
//{
//	TestSList2();
//
//	// 要改变int，传int的地址，解引用改变
//	//int x = 0;
//	//f1(&x);
//	//printf("%d\n", x);
//
//	 要改变int*，传int*的地址，解引用改变
//	//int* ptr = NULL;
//	//f2(&ptr);
//	//printf("%p\n", ptr);
//
//
//	return 0;
//}




struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* removeElements(struct ListNode* head, int val){
	struct ListNode* prev = NULL;
	struct ListNode* cur = head;
	while (cur)
	{
		if (cur->val == val)
		{
			// 头删
			if (cur == head) //if(prev == NULL)
			{
				head = cur->next;
				free(cur);
				cur = head;
			}
			else
			{
				// 删除
				prev->next = cur->next;
				free(cur);
				cur = prev->next;
			}
		}
		else
		{
			prev = cur;
			cur = cur->next;
		}
	}

	return head;
}

int main()
{
	struct ListNode* n1 = (struct ListNode*)malloc(sizeof(struct ListNode));
	assert(n1);

	struct ListNode* n2 = (struct ListNode*)malloc(sizeof(struct ListNode));
	assert(n2);

	struct ListNode* n3 = (struct ListNode*)malloc(sizeof(struct ListNode));
	assert(n3);

	struct ListNode* n4 = (struct ListNode*)malloc(sizeof(struct ListNode));
	assert(n4);

	n1->val = 7;
	n2->val = 7;
	n3->val = 7;
	n4->val = 7;

	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = NULL;

	struct ListNode* head = removeElements(n1, 7);


	return 0;
}

lihua777
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
【数据结构与算法】---链表
weixin_67900732的博客
08-04 3999
今天小编带大家学习数据结构中的链表。
无头单链表的基本操作（Java）
qq_44723296的博客
10-28 367
链表： 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 其实呢，链表的结构非常多样，分为以下情况 单向 双向 无头 有头 循环 非循环 这次呢，先说无头单向非循环链表 链表的实现： //结点类 class ListNode{ public int data; public ListNode next; public L...
C语言实现链表（无头+单向+非循环）
xiao3399的博客
12-21 155
C语言实现链表（无头+单向+非循环）
【数据结构与算法】详解单向无头非循环链表的基本操作
云泽野の编程日记
10-19 710
对于插入数据，只考虑插入位置的特殊性还是不够的，
链表详解（一）—— 无头单向非循环链表
2021dragon的博客
04-08 2820
文章目录链表介绍初始化链表打印单链表增加数据单链表的头插单链表的尾插删除数据单链表的头删单链表的尾删 链表介绍 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 实际中，链表的结构多种多样： 1、带头，不带头。 2、单向，双向。 3、循环，非循环。 通过以上的这些情况组合起来，就有八种
Java之单链表篇！！！ （无头单向非循环链表实现打印、头插、尾插、任意插入、查找、删除某一关键字、删除所有所选关键字、清空单链表等基本操作）
12-21
首先对单链表的结构进行介绍，单链表是由很多个节点一个接一个串接起来的，每个节点包含两部分，数据部分和地址部分，我们这里讲的是无头的单链表，所以没有头节点，每个节点存储的是本身的数据和下一个节点的地址。...
Python实现-无头单向非循环链表
12-22
无头单向非循环链表链表 无头单向非循环链表结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等 无头单向非循环链表 对于任意一个数据元素a(i)来说，储存本身的...
单向链表基本操作的递归实现
08-10
这几天正在复习一些基本的算法和实现，今天看了看递归的基本原理，发现自己对递归还不是特别清楚，特别是不清楚递归的思想，不能很准确的把握先分解成小事件，在合并的思想，其实也是数学归纳法的程序体现，其实数学...
C语言实现单链表逆序与逆序输出实例
09-04
主要介绍了C语言实现单链表逆序与逆序输出,是数据结构与算法中比较基础的重要内容,有必要加以牢固掌握,需要的朋友可以参考下
无头单向链表接口的实现
翟黎明的博客
09-16 109
链表的接口实现
Java实现单向无头链表
weixin_46429649的博客
11-12 805
class ListNode{ public int val; public ListNode next; public ListNode(){ } public ListNode(int val){ this.val = val; } } public class MyLinkedList { public ListNode head; //得到单链表的长度 public int size(){
线性表之无头单向非循环链表
m0_62171658的博客
03-06 703
线性表之无头单向非循环链表详解
【数据结构】-----链表（无头单向非循环链表的实现+常见链表面试题）
m0_55752775的博客
10-04 528
无头单向非循环链表增删查改实现 带头双向循环链表增删查改实现 顺序表和链表的优缺点 删除链表中等于给定值 val 的所有节点。 反转一个单链表。 返回链表的中间节点。 输入一个链表，输出该链表中倒数第k个结点。 将两个有序链表合并为一个新的有序链表并返回。 分割链表。 链表的回文结构 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 NULL 给定一个链表，每个节点包含一个额外增加的随机指针，该指针可以指向链表中的任何节点或空节点。要求返回这个链表的深度拷贝。
无头单链表的解析与实现
tt 博客
05-30 659
概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的引用链 接次序实现的 。 // 1、无头单向非循环链表实现 public interface ILinked { //头插法 void addFirst(int data); //尾插法 void addLast(int data); //任意位置插入,第一个数据节点为0号下标 boolean addinde...
【数据结构】单链表（无头单向非循环链表）的实现
m0_52347974的博客
01-06 395
单链表
（数据结构）顺序表和链表
Captain_ldx的博客
08-07 564
一份详细的顺序表链表实现笔记！
无头结点单链表的逆置_无头结点的单链表（C语言）
weixin_33281940的博客
02-12 856
1.单链表：在顺序表中，用一组地址连续的存储单元来一次存放线性表的结点，因此结点的逻辑顺序与物理顺序是一致的。但链表却不同，链表是用一组任意的存储单元来存放 线性表的结点，这组存储单元可以是连续的，也可以是非连续的，甚至是零散分布在内存的任何位置上。因此，链表中结点的逻辑顺序与物理顺序不一定相同。为了正确表示节点间的逻辑关系，必须在存储线性表的每个数据元素的同时，存储指示其后继结点的地址信息，这两...
小白学编程之单向链表（无头节点）
Super_Market_Z的博客
08-20 796
小白学编程之单向链表（无头节点）
数据结构顺序表——单向无头链表
m0_56611833的博客
11-05 167
文章目录链表概念单链表结构定义申请节点单链表打印单链表尾插单链表头插单链表尾删单链表头删单链表查找在pos后一个位置插入一个节点在pos前面一个位置插入一个节点删除pos节点删除pos后一个节点销毁链表总结 链表概念 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 链表也是顺序表的一种。 主要和数组顺序表对比。 链表有单向、双向；带头、不带头；循环、不循环几种，可以有8种组合： 实际中最常用的两种结构是单向无头链表和双向带头循环链表这两种结构
约瑟夫问题Ｃ语言单向链表实现
最新发布
03-29
现在我来介绍一下如何使用C语言的单向链表来实现约瑟夫问题。 首先，我们需要定义一个链表节点的结构体，包含两个成员变量：一个是保存人员编号的整型变量，另一个是指向下一个节点的指针。 ```c typedef struct ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值