单双链表和顺序表的代码实现

最新推荐文章于 2025-02-07 21:19:33 发布
原创 最新推荐文章于 2025-02-07 21:19:33 发布 · 233 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #数据结构

 1.单链表的代码实现

我们先创建单链表的头文件

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include"contact.h"
//定义节点的结构
//数据 + 指向下一个节点的指针
typedef int SLTDataType;//将数据类型重命名

typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;//定义一个单链表

//声明函数

//打印函数
void SLTPrint(SLTNode* phead);
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);
//尾删
void SLTPopBack(SLTNode** pphead);
//头删
void SLTPopFront(SLTNode** pphead);
//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);
//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);
//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos);
//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos);
//销毁链表
void SListDesTroy(SLTNode** pphead);

加入相对应的头文件，然后声明函数。

#include"SList.h"
//打印链表
void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)//pcur != NULL
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}
//创建链表
SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//*pphead 就是指向第一个节点的指针
	//空链表和非空链表
	SLTNode* newnode = SLTBuyNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找尾
		SLTNode* ptail = *pphead;
		while (ptail->next!=NULL)
		{
			ptail = ptail->next;
		}
		//ptail指向的就是尾结点
		ptail->next = newnode;
	}
}

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

//尾删
void SLTPopBack(SLTNode** pphead)
{
	//链表不能为空
	assert(pphead && *pphead);
	//只有一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//多个节点
	else
	{
		SLTNode* prev = *pphead;
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		free(ptail);
		ptail = NULL;
		prev->next = NULL;
	}
}

//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

//查找
//SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
//{
//	SLTNode* pcur = phead;
//	while (pcur)
//	{
//		if (pcur->data == x)
//		{
//			return pcur;
//		}
//		pcur = pcur->next;
//	}
//	return NULL;
//}

//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	//若pos == *pphead;说明是头插
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		newnode->next = pos;
		prev->next = newnode;
	}
}

//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);
	assert(pos);
	//pos是不是头节点
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

// 删除pos之后的节点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	SLTNode* prev = pos->next;
	pos->next = prev->next;
	free(prev);
	prev = NULL;
}

//销毁链表
void SListDesTroy(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* del = *pphead;
	while (del)
	{
		SLTNode* next = del->next;
		free(del);
		del = next;
	}
	*pphead = NULL;
}

2.双链表的代码实现

加入.h文件

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

typedef int LTDataType;
typedef struct ListNode
{
	LTDataType Data;
	 struct ListNode* next;
	 struct ListNode* prev;
}LTNode;

//void LTInit(LTNode** pphead);
//初始化
LTNode* LTInit();
//销毁链表
void LTDestroy(LTNode* phead);
//打印
void LTPrint(LTNode* phead);
bool LTEmpty(LTNode* phead);
//尾插/尾删
void LTPushBack(LTNode* phead, LTDataType x);
void LTPopBack(LTNode* phead);
//头插/头删
void LTPushFront(LTNode* phead, LTDataType x);
void LTPopFront(LTNode* phead);
//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x);
//删除pos节点
void LTErase(LTNode* pos);
//查找
LTNode* LTFind(LTNode* phead, LTDataType x);

 加入.c文件

#include"DList.h"

//打印
void LTPrint(LTNode* phead)
{
	LTNode* pcur =  phead->next;
	while (pcur != phead)
	{
		printf("%d->", pcur->Data);
		pcur = pcur->next;
	}
	printf("\n");
}

//申请节点
LTNode* LTBuyNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(1);
	}
	else
	{
		node->Data = x;
		node->next =node->prev = node;
	}
	return node;
}

//创建哨兵位
LTNode* LTInit()
{
	LTNode* pphead = LTBuyNode(-1);
	return pphead;
}

//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = phead->next;
	newnode->next = phead;

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

//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead&&phead->next!=phead);
	LTNode* del = phead->next;
	del->prev->next = phead;
	phead->prev = del->prev;
	free(del);
	del = NULL;
}

//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = phead;
	newnode->next = phead->next;

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

//头删
void LTPopFront(LTNode* phead)
{
	assert(phead && phead->next != phead);
	LTNode* del = phead->next;
	del->next->prev = phead;
	phead->next = del->next;
	free(del);
	del = NULL;
}

//查找
LTNode* LTFind(LTNode* phead, LTDataType x)
{
	LTNode* pcur = phead->next;
	while (pcur!=phead)
	{
		if (pcur->Data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

//在pos之后插入数据
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	newnode->next = pos->next;
	newnode->prev = pos;

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

//删除pos节点
void LTErase(LTNode* pos)
{
	assert(pos);
	pos->next->prev = pos->prev;
	pos->prev->next = pos->next;
	free(pos);
	pos = NULL;
}

//销毁链表
void LTDesTroy(LTNode* phead)
{
	assert(phead);
	LTNode* del = phead->next;
	while (del != phead)
	{
		LTNode* next = del->next;
		free(del);
		del = next;
	}
	free(phead);
	phead = NULL;
}

3.顺序表的代码实现

加入.h文件

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include"Contact.h"
//定义顺序表结构


//动态顺序表
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* arr;
	int size; //有效数据个数
	int capacity;//空间大小
}SL;

//顺序表的初始化
void SLInit(SL* ps);
//顺序表的销毁
void SLDestroy(SL* ps);
//顺序表的打印
void SLPrint(SL s);

//头部的插入删除//尾部的插入删除
void SLPushFront(SL* ps, SLDataType x);
void SLPushBack(SL* ps, SLDataType x);

void SLPopFront(SL* ps);
void SLPopBack(SL* ps);

//指定位置之前插入 //删除数据
void SLInsert(SL * ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);
int SLFind(SL* ps, SLDataType x);

 加入.c

#include"SeqList.h"
//顺序表的初始化
void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}
//顺序表的销毁
void SLDestroy(SL* ps)
{
	if (ps->arr) //等价于  if(ps->arr != NULL)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}
//顺序表增加空间
void SLCheckCapacity(SL* ps)
{
	//插入数据之前先看空间够不够
	if (ps->capacity == ps->size)
	{
		//申请空间
		//malloc calloc realloc  int arr[100] --->增容realloc
		//三目表达式
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;//要申请多大的空间
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);//直接退出程序，不再继续执行
		}
		//空间申请成功
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
}
//尾插
void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps); 
	//ps->arr[ps->size] = x;
	//++ps->size;
	SLCheckCapacity(ps);
	ps->arr[ps->size++] = x;
}
//头插
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	//先让顺序表中已有的数据整体往后挪动一位
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//arr[1] = arr[0]
	}
	ps->arr[0] = x;
	ps->size++;
}
//顺序表的打印
void SLPrint(SL s)
{
	for (int i = 0; i < s.size; i++)
	{
		printf("%d ", s.arr[i]);
	}
	printf("\n");
}
//尾删
void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);
	//顺序表不为空
	//ps->arr[ps->size - 1] = -1;
	--ps->size;
}
//头删
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size);
	//数据整体往前挪动一位
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1]; //arr[size-2] = arr[size-1]
	}
	ps->size--;
}
//在指定位置之前插入数据
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	//插入数据：空间够不够
	SLCheckCapacity(ps);
	//让pos及之后的数据整体往后挪动一位
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//arr[pos+1] = arr[pos]
	}
	ps->arr[pos] = x;
	ps->size++;
}
//删除指定位置的数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

	for (int i = pos; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}
//查找
//int SLFind(SL* ps, SLDataType x)
//{
//	assert(ps);
//	for (int i = 0; i < ps->size; i++)
//	{
//		if (ps->arr[i] == x)
//		{
//			//找到啦
//			return i;
//		}
//	}
//	//没有找到
//	return -1;
//}

以上就是链表和顺序表的代码啦，对你有帮助记得三连~ 

陈大大川
关注
顺序表与链表
m0_56931704的博客
09-06 1600
顺序表与链表 一.顺序表 1.定义：将表中元素一个接一个的存入一组连续的存储单元中，这种存储结构是顺序结构。采用顺序存储结构的线性表简称为“ 顺序表”。 顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中 顺序表可以分为静态顺序表和动态顺序表 2.结构定义： #define MAXSIZE 100 typedef int ElemType; typedef struct Seqlist {//静态顺序表 ElemType data[MAXSIZE]; size_t size
【数据结构】单链表完整代码实现
飞舞的蓝色雪花
11-21 4914
数据结构中单链表的完整代码实现。
单链表（详细代码）
Toprogram的博客
08-03 886
是数据结构中线性表的一种，和顺序表不同，其在内存中的数据是的。和是顺序存储的，也就是内存是连续的；而是通过指针将不连续的内存连接起来，实现链式储存的。
数据结构单向链表操作（全部代码）
weixin_57325286的博客
07-20 805
数据结构单向链表操作（全部代码）
单向链表的代码实现（vi编辑器）
qq_43761725的博客
02-26 192
单向链表的插入，删除，遍历,反转
c语言单向链表
欢迎来到梨+萍的博客，不准备看点啥学习嘛。。。
08-08 2180
简单c语言实现单向链表！
线性表实现代码(内涵顺序表静态动态分配，循环，单双链表)
10-27
在本压缩包中，"线性表实现代码(内涵顺序表静态动态分配，循环，单双链表)" 提供了线性表在不同情况下的具体实现，包括顺序表和链表两种基本形式，以及它们的不同操作方式。 1. **顺序表**： - 静态分配：在内存中...
单双链表操作与逆序遍历实现
本文件标题为“linkedlist_链表_”，描述中明确指出涵盖单双链表的创建、节点的添加与删除、链表逆序以及链表遍历等核心操作，结合标签内容可以看出，该资源系统地讲解了链表这一数据结构的核心知识点，是学习数据...
线性表代码实现详解：静态与动态，循环及单双链表
资源摘要信息: "线性表实现代码(内涵顺序表静态动态分配，循环，单双链表)" 线性表是一种基本且重要的数据结构，它是具有相同性质数据元素的有限序列。在计算机科学中，线性表可以使用数组或链表等方式实现。本资源...
数据结构实现：单双链表操作代码详解
综合以上信息，我们可以得出该压缩包子文件可能是一系列关于数据结构的代码示例和练习题，涵盖了单链表、双链表、顺序表的实现，以及它们相关操作的代码实现。这些内容对于学习数据结构和算法，特别是对于理解线性表...
【数据结构】单链表（超详细讲解）c代码实现
qq_59702185的博客
08-13 2022
传值只是创建一个临时变量phead，只会改变phead的值，并不会改变我们想要的plist的值。当我们传plist的值时，因为当链表为空时，我们要创建第一个节点，我们要改变plist的指向，让他指向第一个节点。当链表不为空时，先要找到链表的最后一个节点，然后将尾结点的next指向新节点。思路一：找到单链表尾结点的上一个节点，通过上一个节点的next指针，找到最后一个节点。所有节点的地址不是连续的，链表在物理结构上不一定是线性的，但在逻辑结构上是线性的。的方式实现的，通过指针的指向，可以使链表。...
数据结构 c 代码2：单链表
cillin9的博客
04-28 1148
** 数据结构 c 代码2：单链表 ** 0.链表概念 线性表的链式存储结构：线性表中数据元素（结点）在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理位置上不一定相邻。 头指针:是指向链表中第一个结点的指针 头结点：是在链表的首元结点之前附设的一个结点 首元节点：是指链表中存储第一个数据元素a1的节点 头结点的数据域（图中info）可以为空，也可以存放线性表长度，此结点不计入链表的长度值 1.创建链表 typedef struct LinkNode { char data; str
数据结构之单链表（c语言附完整代码）
热门推荐
m0_62795460的博客
11-01 1万+
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。声明单链表//数据域 struct LNode * next;//指针域，指向后继结点 } LinkNode;//声明单链表结点类型注意：本文章讨论的单链表是带头结点的单链表。
单向链表的C语言实现
Broken_x的博客
05-28 1768
首先，我们需要定义单向链表的结点和链表本身的结构// 单向链表的结点定义// 数据域// 指针域，指向后继结点} Listnode;// 单向链表的定义// 头结点// 整个链表的元素个数和：包含标准输入输出和标准库函数。：定义链表中数据的类型为int，可以根据需要更改。：定义链表结点结构体，包含数据域data和指向后继结点的指针next。：定义链表结构体，包含指向头结点的指针head和链表的元素个数size。
数据结构——单向链表的编写
最新发布
weixin_48141383的博客
02-07 449
要求：使用封装工程代码完成链表的定义、创建、头插入、显示、删除、查找、替换、尾插入等功能。其定义为：（1）创建链表：（2）链表头插入：（3）链表元素显示：（4）链表元素删除：（5）链表元素查找：（6）链表元素替换：（7）链表尾插入：要实现以下函数需要创建3个文件，分别为：main.c , linklist.c , linklist.h。使用此格式可以更方便阅读和编写。
单向链表代码实现
jiaona_chen123的博客
06-03 227
单向链表
单链表代码实现
qq_51302626的博客
02-17 809
单链表代码实现 // 单链表.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include <iostream> using namespace std; #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemType; typedef int Status; typedef struct Node { ElemType data; str
数据结构--单向链表的代码实现(c++)
qq_52696286的博客
10-12 216
1.链表构造 节点构造： template <typename type> struct node{ type val; node<type> *next; node() {next=NULL;} node(type &x,type<T1> *p){val=x;next=p;} }; 链表构造： template <typename type> class list{ public: node
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值