单链表

最新推荐文章于 2024-07-25 15:58:50 发布
最新推荐文章于 2024-07-25 15:58:50 发布
阅读量68 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45035125/article/details/105817706
版权

单链表
在这里插入图片描述
用C语言实现单链表，完成头插、尾插、头删、尾删、排序、查找、清空等操作…

testMain.c

#include"list.h"

int main()
{
	SList mylist;
	SListInit(&mylist);

	SListNode *p;
	ElemType item, key;
	int select = 1;
	int pos = 0;
	while (select)
	{
		printf("*********************************************\n");
		printf("*  [1]push_back             [2]push_front   *\n");
		printf("*  [3]show_list             [4]pop_back     *\n");
		printf("*  [5]pop_front             [6]insert_value *\n");
		printf("*  [7]delete_value          [8]find_value   *\n");
		printf("*  [9]length                [10]sort        *\n");
		printf("*  [11]reverse              [12]clear       *\n");
		printf("*  [0]quit_system                           *\n");
		printf("*********************************************\n");
		printf("请选择:>");
		scanf("%d", &select);
		if (select == 0)
			break;
		switch (select)
		{
		case 1:
			printf("请输入要插入的值[以-1结束]:>");
			while (scanf("%d", &item), item != -1)
			{
				SListPushBack(&mylist, item);
			}
			printf("尾部插入数据成功...\n");
			break;
		case 2:
			printf("请输入要插入的值[以-1结束]:>");
			while (scanf("%d", &item), item != -1)
			{
				SListPushFront(&mylist, item);
			}
			printf("头部插入数据成功...\n");
			break;
		case 3:
			SListShow(&mylist);
			break;
		case 4:
			SListPopBack(&mylist);
			printf("尾部删除数据成功...\n");
			break;
		case 5:
			SListPopFront(&mylist);
			printf("头部删除数据成功...\n");
			break;
		case 6:
			printf("请输入要插入的位置:>");
			scanf("%d", &pos);
			printf("请输入要插入的数据:>");
			scanf("%d", &item);
			SListInsertByVal(&mylist, pos, item);
			break;
		case 7:
			printf("请输入要删除的值:>");
			scanf("%d", &key);
			SListDeleteByVal(&mylist, key);
			printf("删除数据成功...\n");
			break;
		case 8:
			printf("请输入要查找的值:>");
			scanf("%d", &key);
			p = SListFind(&mylist, key);
			if (p == NULL)
				printf("要查找的值不存在.\n");
			else
				printf("要查找的值为:> %p\n", &(p->data));
			break;
		case 9:
			printf("seqlist len = %d\n", SListLength(&mylist));
			break;
		case 10:
			SListSort(&mylist);
			printf("链表排序成功......\n");
			break;
		case 11:
			SListReverse(&mylist);
			printf("链表逆序成功...\n");
			break;
		case 12:
			SListClear(&mylist);
			printf("清除数据表成功......\n");
			break;
		}
	}
	SListDestroy(&mylist);
	printf("GoodBye......\n");
	return 0;
}

common.h

#ifndef _COMMON_H_
#define _COMMOM_H_

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

#define ElemType int

void Swap(ElemType *a, ElemType *b)
{
	ElemType temp = *a;
	*a = *b;
	*b = temp;
}

#endif /*_COMMOM_H_*/

list.h

#ifndef _LIST_H_
#define _LIST_H_

#include"common.h"

typedef struct SListNode
{
	ElemType data;
	struct SListNode *next;
}SListNode;

typedef struct SList
{
	SListNode *head;
}SList;

///
//单链表的函数接口声明
static SListNode* _Buynode(ElemType x);
void SListInit(SList *plist);
void SListPushBack(SList *plist, ElemType x);
void SListPushFront(SList *plist, ElemType x);
void SListPopBack(SList *plist);
void SListPopFront(SList *plist);
void SListDestroy(SList *plist);

void SListInsertByVal(SList *plist, ElemType x);

SListNode* SListFind(SList *plist, ElemType key);
void SListDeleteByVal(SList *plist, ElemType key);

void SListClear(SList *plist);
size_t SListLength(SList *plist);

void SListReverse(SList *plist);
void SListSort(SList *plist);

void SListShow(SList *plist);

//
//单链表的函数接口实现

//申请节点
static SListNode* _Buynode(ElemType x)
{
	SListNode *s = (SListNode*)malloc(sizeof(SListNode));
	assert(s != NULL);
	s->data = x;
	s->next = NULL;
	return s;
}

//初始化head指针
void SListInit(SList *plist)
{
	plist->head = NULL;
}

//尾插
void SListPushBack(SList *plist, ElemType x)
{
	assert(plist != NULL);

	SListNode *s = _Buynode(x);

	//插入的节点为第一个节点
	if (plist->head == NULL)
	{
		plist->head = s;
		return;
	}

	//O(n)
	SListNode *p = plist->head;
	//查找链表的尾部节点 
	while (p->next != NULL)
		p = p->next;
	p->next = s;
}

//头插
void SListPushFront(SList *plist, ElemType x)
{
	assert(plist != NULL);
	SListNode *s = _Buynode(x);

	//O(1)
	s->next = plist->head;
	plist->head = s;
}

//尾删
void SListPopBack(SList *plist)
{
	assert(plist != NULL);
	SListNode *p, *prev;
	if (plist->head == NULL)
		return;
	p = plist->head;
	//链表只有一个节点
	if (p->next == NULL)
		plist->head = NULL;
	else
	{
		while (p->next != NULL)
		{
			prev = p;
			p = p->next;
		}
		prev->next = NULL;
	}
	free(p);
}

//头删除
void SListPopFront(SList *plist)
{
	assert(plist != NULL);
	SListNode *p = plist->head;
	if (plist->head == NULL)
		return;

	plist->head = p->next;
	free(p);
}

//按值查找
SListNode* SListFind(SList *plist, ElemType key)
{
	assert(plist != NULL);
	SListNode *p = plist->head;

	//空链表 NULL
	//存在   P
	//不存在 NULL

	while (p != NULL && p->data != key)
		p = p->next;
	return p;
}

//按值删除
void SListDeleteByVal(SList *plist, ElemType key)
{
	assert(plist != NULL);
	SListNode *prev = NULL;
	SListNode *p = SListFind(plist, key);
	if (p == NULL)
	{
		printf("要删除的节点不存在.\n");
		return;
	}

	if (p == plist->head)
		plist->head = p->next;
	else
	{
		prev = plist->head;
		while (prev->next != p)
			prev = prev->next;

		//删除节点
		prev->next = p->next;
	}
	free(p);
}

//链表长度
size_t SListLength(SList *plist)
{
	assert(plist != NULL);
	size_t len = 0;
	SListNode *p = plist->head;

	while (p != NULL)
	{
		len++;
		p = p->next;
	}
	return len;
}

//打印链表
void SListShow(SList *plist)
{
	assert(plist != NULL);
	SListNode * p = plist->head;
	while (p != NULL)
	{
		printf("%d-->", p->data);
		p = p->next;
	}
	printf("Over.\n");
}

//摧毁链表
void SListDestroy(SList *plist)
{
	SListClear(plist);
	plist->head = NULL;
}

//清空链表
void SListClear(SList *plist)
{
	assert(plist != NULL);
	SListNode *p = plist->head;
	while (p != NULL)
	{
		plist->head = p->next;
		free(p);
		p = plist->head;
	}
}

//链表逆序
void SListReverse(SList *plist)
{
	assert(plist != NULL);
	SListNode *p = plist->head->next;
	SListNode *q;
	if (p->next == NULL)
		return;

	//断开第一个节点
	plist->head->next = NULL;
	while (p != NULL)
	{
		q = p->next;
		p->next = plist->head;
		plist->head = p;
		p = q;
	}
}

//按值插入
void SListInsertByVal(SList *plist, ElemType x)
{
	assert(plist != NULL);
	SListNode *prev = NULL;
	SListNode *p = plist->head;

	SListNode *s = _Buynode(x);

	while (p != NULL && x>p->data)
	{
		prev = p;
		p = p->next;
	}

	if (prev == NULL) //需要进行头插
	{
		s->next = p;
		plist->head = s;
	}
	else
	{
		s->next = prev->next;
		prev->next = s;
	}
}

//排序
void SListSort(SList *plist)
{
	assert(plist != NULL);
	SListNode *p = plist->head->next;
	SListNode *q, *t, *prev = NULL;

	plist->head->next = NULL; //断开链表

	t = plist->head;
	while (p != NULL)
	{
		q = p->next;
		//把p节点摘除进行按值插入，升序
		while (t != NULL && p->data > t->data)
		{
			prev = t;
			t = t->next;
		}
		if (prev == NULL)
		{
			p->next = plist->head;
			plist->head = p;
		}
		else
		{
			p->next = prev->next;
			prev->next = p;
		}
		p = q;
		t = plist->head;
	}
}

#endif /* _LIST_H_ */
在下yo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表插入
兔子王
09-23 851
【问题描述】 设有头结点单链表，实现单链表插入算法。 【输入形式】 第一行输入一个N（N大于等于1，小于1000）； 第二行输入N个整数，以空格作为分隔，创建长度为N的单链表； 第三行输入pos和e，以空格分隔，分别表示插入位置和插入元素的值。 【输出形式】 若插入成功，输出插入元素后的单链表；若插入不成功，输出error。
单链表删除
兔子王
09-22 1676
【问题描述】 设有头结点单链表，实现单链表删除。 【输入形式】 第一行输入N，表示单链表表长为N； 第二行输入N个整数，建立有头结点单链表； 第三行输入一个整数M，表示删除结点位置为M（即第M个元素）。 【输出形式】 若删除成功，先输出删除结点的值；下一行输出删除后单链表的所有元素； 若删除不成功，输出error。 【样例输入1】 5 10 20 30 40 50 2 【样例输出1】 20 10 30 40 50 【样例输入2】 10 10 20 30 40 50 60
数据结构-单链表基本操作-C语言代码
热门推荐
suxiaorui的博客
01-22 6万+
单链表基本操作 1.头插法建立单链表 2.尾插法建立单链表 3.查找结点 3.修改结点 4.插入结点 5.删除结点 本篇只有c语言代码，具体思路讲解请看这篇博客：数据结构-线性结构-单链表 1.头插法建立单链表 #include<stdio.h> #include<stdlib.h> //单链表的结构定义 typedef struct LNode { int data...
建立单链表
Dream_begin_的博客
01-11 4841
链表是动态地进行存储分配的一种结构，链表中的数据在内存中不必连续存放，数据之间通过指针链接起来，相比于数组结构，链表的插入和删除操作比较方便。单链表的建立链表：通过自引用结构的指针域，将各结点相互连接。关于链表的基本概念： (1)链表的第一个结点称头指针或头结点，它指向链表在内存中的首地址， (2)其后的结点是通过结点中的链节指针成员访问的。 (3)链表的最后一个结点称为尾节点。尾节点的指针域通常被设置成NULL。 (4)链表中的每一个结点是在需要的时候建立的。 (5)各结点在内存中的存储地址不一
C语言单链表
knighthood2001
05-06 1499
int data;} Node;这里我们使用typedef将struct Node命名为Node。当然很多书以及代码中会使用到如下的int data;这里它还定义了一个指向这个结点的指针，当然对于初学者（笔者也是初学者）来说。使用*LinkList后，不太好理解，这里笔者就使用上述Node的版本。
单链表简单实现
南猿北者博客
10-31 2148
单链表逻辑图：单链表同顺序表一样，都是线性表，除了首尾节点之外，任何一个节点都有自己的前驱和后继；但是单链表每个节点在物理上的地址是不连续的或者说是随机的，也就是说单链表的节点是要一个就开一个，不会过多的开辟空间；这一点正是弥补了顺序表的不足；从上面的逻辑图我们就可以看出，每个节点的类型应该是一样的，节点主要分为数据域和指针域，同时对于一串链表来所，最后一个节点的指针域一定是NULL，以此来标记这是链表的结尾；同时我们只需要知道单链表的头节点，就可以很好的管理整个链表；
C++单链表逆序
m0_51380378的博客
07-12 971
牛客网真题：单链表的逆序 C++的单链表逆序： 创建3个指针，分别指向当前头节点位置，空空。 先将一个指针指向头节点的下一个节点，下一个节点为当前节点的下一个节点，当前节点的下一个节点为前一个节点，前一个结点为当前节点，当前节点为下一个节点。 struct ListNode* ReverseList(struct ListNode* pHead ) { // write code here struct ListNode *pre = NULL; struct Li
关于单链表
CSDN_YJX的博客
04-07 116
基础知识：什么是单链表，链式存储结构详解 单链表 基础操作：单链表的基本操作（C语言版） 最后附加一篇大佬的文章 【C语言】链表及单链表基本操作
C++单链表
weixin_62313265的博客
12-13 5098
链表是一种常见的数据结构。它主要是利用动态内存分配、结合结构体并配合指针来实现的，能根据需要开辟和释放内存单元。
单链表代码
02-01
单链表是一种基础的数据结构，它在计算机科学和编程中有着广泛的应用。在这个"单链表代码"压缩包中，我们可以找到用C语言实现的单链表操作的示例代码，这些代码通常会涵盖单链表的基本操作，如创建、插入、删除节点...
单链表逆序
03-04
单链表逆序是数据结构领域中的一个常见操作，它涉及到对链表节点顺序的反转。在本场景中，我们将详细探讨如何实现这个过程，包括单链表的基本概念、逆序算法的步骤以及如何在实际编程中应用这些概念。 首先，我们...
单链表的实现
04-21
单链表是一种基础的数据结构，它在计算机科学中扮演着重要的角色。单链表由一系列节点组成，每个节点包含两部分：数据元素和一个指向下一个节点的指针。这种数据结构允许快速的插入和删除操作，但随机访问的效率较低...
3.1、数据结构-线性表
最新发布
yoyo勰的博客
07-25 658
顺序列表由于元素与元素之间是相邻的，我们可以直接从首元素来查到每个元素的位置。【2021年】设有栈S和队列Q初始状态为空,数据元素序列a,b,c,d,e,f依次通过栈S,且多个元素从S出栈后立即进入队列Q,若出队的序列是b,d,f,e,c,a,则S中的元素最多时,栈底到栈顶的元素依次为()。在时间方面，由顺序表和链表的存储方式可知，当需要对元素进行破坏性操作（插入、删除）时，链表效率更高，因为其只需要修改指针指向即可，而顺序表因为地址是连续的，当删除或插入一个元素后，后面的其他节点位置都需要变动。
数据结构——二叉树性质
鲸落博客
07-23 534
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 399
对于二分搜索的理论与实现的知识点学习。
【数据结构】——双链表的实现（赋源码）
ZWW_zhangww的博客
07-24 664
它的结构示意图如下注意：这⾥的“带头”跟前⾯我们说的单链表的“头结点”是两个概念，实际前⾯的在单链表阶段称呼不严谨，但是为了读者们更好的理解就直接称为单链表的头结点。带头链表⾥的头结点，实际为“”，哨兵位结点不存储任何有效元素，只是站在这⾥“放哨的”也可以认为是用来占位置滴！！！
7.24数据结构
2301_81236242的博客
07-24 541
1>树形结构：表示数据元素之间存在一对多的关系2>树：是由一个根节点多个子树构成的树形结构3>节点：就是树中的数据元素4>父亲节点：当前节点的直接上级节点5>孩子节点：当前节点的直接下架节点6>祖先节点：当前节点的直接或间接上级节点7>子孙节点：当前节点的直接或间接下级节点8>兄弟节点：拥有相同父节点的所有节点互称为兄弟节点9>堂兄弟节点：其父节点在同一层的所有节点，互为堂兄弟节点10>根节点：没有父节点的节点11>叶子节点：没有子节点的节点称为叶子节点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值