顺序表、单向链表和双向链表

最新推荐文章于 2023-05-12 23:22:55 发布
最新推荐文章于 2023-05-12 23:22:55 发布
阅读量682 收藏
点赞数
分类专栏： 数据结构基础 文章标签： 顺序表 链表 双向链表 C语言实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44339734/article/details/103230027
版权

顺序表、单向链表和双向链表


关于循环单向链表和循环双向链表请将鼠标移步 此处点击

1.顺序表

实现代码：

//#pragma once				//作为头文件时加上这行
#include<stdio.h>
#define LIST_MAXSIZE 50		//顺序表最大能存的元素个数
typedef int DataType ;		//元素的数据类型
typedef struct {
	DataType list[LIST_MAXSIZE];
	int size;	//顺序表的元素数量
}SeqList;
/*初始化顺序表，将L->size置为0*/
void ListInit(SeqList* L);
/*判断顺序表是否非空*/
int ListNotEmpty(SeqList* L);
/*在下标为i[0,size]的位置处插入一个元素x，位于该处及该处后的元素依次后移，成功返回1，失败返回0*/
int ListInsert(SeqList* L, int i,DataType x);
/*将下标为i[0,size]的位置元素删除，并把值保存在x中，位于该元素后的依次前移，成功返回1，失败返回0*/
int ListDelete(SeqList* L, int i, DataType *x);
/*放问下标为i[0,size]的位置元素，并把值保存在x中，成功返回1，失败返回0*/
int ListGet(SeqList* L, int i, DataType *x);

void ListInit(SeqList* L)
{
	L->size = 0;
}
int ListNotEmpty(SeqList* q)
{
	if (q->size != 0)return 1;
	else return 0;
}
int ListInsert(SeqList* L, int i, DataType x)
{
	int j=L->size;
	if (i < 0 || i > L->size) {
		printf("插入位置i，参数不合法\n");
		return 0;
	}
	if (L->size == LIST_MAXSIZE) {
		printf("顺序表已满，无法插入\n");
		return 0;
	}
	while (j > i) //把原位于i及之后的位置上的元素右移
	{
		L->list[j] = L->list[j - 1];
		j--;
	}
	L->list[i] = x;	//把x插进去
	L->size++;
	return 1;
}
int ListDelete(SeqList* L, int i, DataType *x)
{
	int j = i + 1;	//记录i元素后一个的下标
	if (!ListNotEmpty(L)) {
		printf("顺序表中元素为空，无元素可删除。\n");
		return 0;
	}
	if (i < 0 || i >= L->size) {
		printf("参数不合法，删除失败。\n");
		return 0;
	}
	*x = L->list[i];	//把删除的元素赋值给*x
	while(j<L->size) 
	{
		L->list[j - 1] = L->list[j];	//将位置i后的元素前移
		j++;
	}
	L->size--;
	return 1;
}
int ListGet(SeqList* L, int i, DataType *x)
{
	if (!ListNotEmpty(L)) {
		printf("顺序表中元素为空，无元素可取。\n");
		return 0;
	}
	if (i < 0 || i >= L->size) {
		printf("参数不合法，取出失败。\n");
		return 0;
	}
	*x = L->list[i];
	return 1;
}

测试函数：

void test()
{
	int i, x;
	SeqList L;	
	ListInit(&L);
	for (i = 0; i < 10; i++)
		ListInsert(&L, i, i);
	printf("将下标为5处的元素删除\n");
	ListDelete(&L, 5, &x);
	printf("被删除的元素为:%d\n", x);
	printf("插入元素10到下标为5处:\n", x);
	ListInsert(&L, 5, 10);
	printf("将链表输出\n");
	for (i = 0; i < L.size ; i++)
	{
		ListGet(&L, i, &x);
		printf("%d ", x);
	}
}

运行结果：
在这里插入图片描述

2.单向链表

实现代码：

//#pragma once				//作为头文件时加上这行
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef int DataType;
typedef struct Node
{
	DataType data;
	struct Node *next;
}LinkedList;

/*以下的第几个结点都不包括头节点，即头结点不计入下标*/

/*初始化链表*/
void ListInit(LinkedList* head);
/*判断链表是否非空*/
int ListNotEmpty(LinkedList* head);
/*返回链表元素个数*/
int ListLength(LinkedList* head);
/*在下标为i[0,size]的位置处插入一个元素x，位于该处及该处后的元素依次后移，成功返回1，失败返回0*/
int ListInsert(LinkedList* head, int i, DataType x);
/*将下标为i[0,size]的位置元素删除，并把值保存在x中，位于该处元素后的元素依次前移，成功返回1，失败返回0*/
int ListDelete(LinkedList* head, int i, DataType *x);
/*放问下标为i[0,size]的位置元素，并把值保存在x中，成功返回1，失败返回0*/
int ListGet(LinkedList* head, int i, DataType *x);
/*撤销单链表的空间*/
void ListDestory(LinkedList* head);

void ListInit(LinkedList* head)
{
	head->next = NULL;
}

int ListNotEmpty(LinkedList* head)
{
	if (head == NULL) {
		printf("头结点为NULL\n");
		return 0;
	}
	if (head->next == NULL)return 0;
	else return 1;
}

int ListLength(LinkedList* head)
{
	int i = 0;
	LinkedList* p = head;
	if (head == NULL) {
		printf("头结点为NULL\n");
		return 0;
	}
	while (p->next != NULL)
	{
		i++;
		p = p->next;
	}
	return i;
}

int ListInsert(LinkedList* head, int i, DataType x)
{
	LinkedList *p = head, *p1 = NULL;
	if (head == NULL) {
		printf("头结点为NULL\n");
		return 0;
	}
	while (p != NULL && i--)	//找到下标为i的结点的前一个结点
		p = p->next;
	if (i != -1) {
		printf("插入参数i不合法\n");
		return 1;
	}
	p1 = (LinkedList*)malloc(sizeof(LinkedList));
	p1->data = x;
	p1->next = p->next;
	p->next = p1;
	return 1;
}

int ListDelete(LinkedList* head, int i, DataType *x)
{
	LinkedList *p = head, *p1 = NULL;
	if (head == NULL) {
		printf("头结点为NULL\n");
		return 0;
	}
	while (p != NULL && i--)	//找到下标为i的结点的前一个结点
		p = p->next;
	if (i != -1) {
		printf("删除参数i不合法\n");
		return 1;
	}
	p1 = p->next;
	*x = p1->data;
	p->next = p1->next;
	free(p1);
}

int ListGet(LinkedList* head, int i, DataType *x)
{
	LinkedList *p = head, *p1 = NULL;
	if (head == NULL) {
		printf("头结点为NULL\n");
		return 0;
	}
	while (p != NULL && i--)	//找到下标为i的结点的前一个结点
		p = p->next;
	if (i != -1) {
		printf("参数i不合法\n");
		return 1;
	}
	p = p->next;
	*x = p->data;
	return 1;
}

void ListDestory(LinkedList* head)
{
	LinkedList *p, *p1 = NULL;
	if (head == NULL) {
		printf("头结点为NULL\n");
		return ;
	}
	p = head->next;
	if (p == NULL)return;
	while (p->next != NULL)
	{
		p1 = p;
		p = p->next;
		free(p1);
	}
	free(p);
}

测试函数：

	int i, x, size;
	//也可用malloc动态申请内存，但是最后要自己调用free释放内存
	LinkedList head;
	ListInit(&head);
	for (i = 0; i < 10; i++)
		ListInsert(&head, i, i);
	printf("将下标为5处的元素删除\n");
	ListDelete(&head, 5, &x);
	printf("被删除的元素为:%d\n", x);
	printf("插入元素10到下标为5处:\n", x);
	ListInsert(&head, 15, 15);	//此行插入不合法 
	ListInsert(&head, 5, 10);
	printf("将链表输出\n");
	size = ListLength(&head);
	for (i = 0; i < size; i++)
	{
		ListGet(&head, i, &x);
		printf("%d ", x);
	}
	ListDestory(&head);

运行结果：
在这里插入图片描述

3.双向链表

实现代码：

//#pragma once				//作为头文件时加上这行
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef int DataType;
typedef struct Node
{
	DataType data;
	struct Node *prior;
	struct Node *next;
}DoublyList;

/*初始化链表,新定义的链表结点必须先初始化*/
void ListInit(DoublyList* head);
/*判断链表是否非空,非空返回1，空返回0*/
int ListNotEmpty(DoublyList* head);
/*返回链表元素个数*/
int ListLength(DoublyList* head);
/*在下标为i[0,size]的位置处插入一个元素x，位于该处及该处后的元素依次后移，成功返回1，失败返回0*/
int ListInsert(DoublyList* head, int i, DataType x);
/*将下标为i[0,size]的位置元素删除，并把值保存在x中，位于该处元素后的元素依次前移，成功返回1，失败返回0*/
int ListDelete(DoublyList* head, int i, DataType *x);
/*放问下标为i[0,size]的位置元素，并把值保存在x中，成功返回1，失败返回0*/
int ListGet(DoublyList* head, int i, DataType *x);
/*撤销单链表的空间*/
void ListDestory(DoublyList* head);

void ListInit(DoublyList* head)
{
	head->prior = NULL;
	head->next = NULL;
}

int ListNotEmpty(DoublyList* head)
{
	if (head == NULL) {
		printf("头结点为NULL\n");
		return;
	}
	if (head->next == NULL)return 0;
	return 1;
}

int ListLength(DoublyList* head)
{
	DoublyList *p = head;
	if (head == NULL) {
		printf("头结点为NULL\n");
		return;
	}
	int i = 0;
	while (p->next != NULL)
	{
		i++;
		p = p->next;
	}
	return i;
}

int ListInsert(DoublyList* head, int i, DataType x)
{
	DoublyList *p = head, *p1 = NULL;
	if (head == NULL) {
		printf("头结点为NULL\n");
		return;
	}
	while (p != NULL && i--)	//找到下标为i的结点的前一个结点
		p = p->next;
	if (i != -1) {
		printf("插入参数i不合法\n");
		return 1;
	}
	p1 = (DoublyList*)malloc(sizeof(DoublyList));
	p1->data = x;
	/*下方代码 将新结点p1加到链表中,位于p后*/
	p1->next = p->next;
	p1->prior = p;
	p->next = p1;
	if (p1->next != NULL)p1->next->prior = p1;	//若插入的元素下标不是链表尾
	return 1;
}

int ListDelete(DoublyList* head, int i, DataType *x)
{
	DoublyList *p = head, *p1 = NULL;
	if (head == NULL) {
		printf("头结点为NULL\n");
		return;
	}
	while (p != NULL && i--)	//找到下标为i的结点的前一个结点
		p = p->next;
	if (i != -1) {
		printf("删除参数i不合法\n");
		return 1;
	}
	p1 = p->next;
	*x = p1->data;
	/*下方代码 将p1从链表中删除*/
	p->next = p1->next;
	if (p1->next != NULL)p1->next->prior = p;	//若插入的元素下标不是链表尾
	free(p1);
	return 1;
}

int ListGet(DoublyList* head, int i, DataType *x)
{
	DoublyList *p = head, *p1 = NULL;
	if (head == NULL) {
		printf("头结点为NULL\n");
		return;
	}
	while (p != NULL && i--)	//找到下标为i的结点的前一个结点
		p = p->next;
	if (i != -1) {
		printf("删除参数i不合法\n");
		return 1;
	}
	p1 = p->next;
	*x = p1->data;
	/*下方代码 将p1从链表中删除*/
	return 1;
}

void ListDestory(DoublyList* head)
{
	DoublyList *p, *p1 = NULL;
	if (head == NULL) {
		printf("头结点为NULL\n");
		return;
	}
	p = head->next;
	if (p == NULL)return;
	while (p->next != NULL)
	{
		p1 = p;
		p = p->next;
		free(p1);
	}
	free(p);
}

测试函数：

void test()
{
	int i, x, size;
	//也可用malloc动态申请内存，但是最后要自己调用free释放内存
	DoublyList head;
	ListInit(&head);
	for (i = 0; i < 10; i++)
		ListInsert(&head, i, i);
	printf("将下标为5处的元素删除\n");
	ListDelete(&head, 5, &x);
	printf("被删除的元素为:%d\n", x);
	printf("插入元素10到下标为5处:\n", x);
	ListInsert(&head, 15, 15);	//此行插入不合法 
	ListInsert(&head, 5, 10);
	printf("将链表输出\n");
	size = ListLength(&head);
	for (i = 0; i < size; i++)
	{
		ListGet(&head, i, &x);
		printf("%d ", x);
	}
	ListDestory(&head);
}

运行结果：
在这里插入图片描述

三寸雪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python单向链表和双向链表原理与用法实例详解
09-20
在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只包含一个指向下一个节点的引用。在单向链表中，遍历只能从头节点开始，按顺序访问每个节点，无法...
实验一：顺序表、单链表
道阻且长，行则将至
09-28 287
单链表的一些操作： ①初始化建立链表 ②输入 ③查找取值 ④插入 ⑤删除 ⑥遍历输出 #include<bits/stdc++.h> #define ENDL puts("") using namespace std; typedef struct LNode { int data; struct LNode *next; }LNode,*LinkList; void...
数据结构——顺序表，单链表，双向链表的实现及全部代码
zhyy-ang的博客
05-12 102
【代码】数据结构——顺序表，单链表，双向链表的实现及全部代码。
数据结构实验报告-实验一 顺序表、单链表基本操作的实现
a8810296的博客
03-29 9105
实验一 顺序表、单链表基本操作的实现 l 实验目的 1、顺序表 （1）掌握线性表的基本运算。 （2）掌握顺序存储的概念，学会对顺序存储数据结构进行操作。 （3）加深对顺序存储数据结构的理解，逐步培养解决实际问题的编程能力。 l 实验内容 1、 顺序表 1、编写线性表基本操作函数： （1）InitList(LIST *L,int ms)初始化线性表；...
顺序表--单链表,双向链表的c语言的基本操作
qq_43610614的博客
10-14 256
链表由各个结点链接而成 结点=数据域+指针域（数据域存储存储数据，指针域存储下一结点的地址） 头指针指向头结点，头结点不存储数据，首元结点为第一个保存数据的结点 下面是单链表用c语言表示的代码 typedef struct Lnode{ //声明结点的类型和指向结点的结点类型 Elemtype data; //结点的数据域，Elemtype为自己使用typedef定义的数据类型 struc...
数据结构实验课：实验一、顺序表的实现及应用
listboy的博客
05-19 1万+
一、实验目的 了解和掌握线性表的顺序存储结构；掌握用C语言上机调试线性表的基本方法；掌握线性表的基本操作：插入、删除、查找以及线性表合并等运算在顺序存储结构和链接存储结构上的运算，以及对相应算法的性能分析。 二、实验要求 给定一段程序代码，程序代码所完成的功能为：（1）建立一个线性表；（2）依次输入数据元素1,2,3,4,5,6,7,8,9,10；（3）删除数据元素5；（4）依次显示当前线性表中的数据元素。假设该线性表的数据元素个数在最坏情况下不会超过100个，要求使用顺序表。 程序中有3处错误的地方，有标
C语言之单向链表详解及实例代码
12-31
单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有...
C语言自学链表，单向链表，双向链表，适合新手学习。
06-18
本资源提供的是针对初学者设计的链表学习材料，包括单向链表和双向链表的实现。下面将详细讲解这两种链表的数据结构及其操作。 1. **单向链表**： 单向链表是一种线性数据结构，每个节点包含两部分：数据域和指针...
8.顺序表和链表1
08-03
链表有多种类型，包括单向链表、双向链表、带头结点和不带头结点的链表，以及循环和非循环链表。无头单向非循环链表常作为其他数据结构的基础，而无头双向链表如Java的LinkedList类，提供了更高效的操作，如双向遍历...
C语言单向链表的表示与实现实例详解
12-31
C语言中的单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的...
实验一 顺序表、单链表基本操作的实现
陈的博客
12-06 2379
实验一 顺序表、单链表基本操作的实现 实验目的 1、顺序表 （1）掌握顺序表的存储结构形式及其描述 （2）掌握顺序表的建立、查找、插入、删除操作 2、链表 （1）掌握单链表的存储结构形式及其描述 （2）掌握单链表的建立、查找、插入和删除操作 实验内容 1、顺序表 编写函数，输入一组整型元素序列，建立一个顺序表。 编写函数，实现对该顺序表的遍历（每个元素被访问一次且仅被访问一次）。 编写函数，在顺序表中顺序查找某一元素，查找成功则返回其存储位置i，否则返回错误信息。 编写函数，实现在顺序表的第i个位置
线性结构——顺序表与链表，循环链表和双向链表
weixin_56631477的博客
12-04 787
顺序表 顺序存储是指在内存中用地址连续的一块存储空间顺序存放线性表的各元素 -元素顺序和地址顺序相同（下标能直接反应元素间的关系）元素的物理位置相邻 -由一维数组实现（但一维数组不一定是顺序存储结构） 顺序存储结构类型定义
双链表——双链表的定义及其基本操作（初始化、头插法尾插法建表、插入、查找、删除、判空等）
热门推荐
薛定谔的猫的博客
04-18 2万+
文章目录双链表的定义双链表上的操作初始化插入操作建立双链表头插法建立双链表尾插法建立双链表遍历操作求双链表的长度查找操作按值查找按位查找删除操作判空操作完整代码及实例总结 双链表的定义  为什么引入双链表？  单链表的结点中只有一个指向其后继的指针，使得单链表要访问某个结点的前驱结点时，只能从头开始遍历，访问后驱结点的复杂度为O(1)，访问前驱结点的复杂度为O(n)。为了克服上述缺点，引入了双链表。  双链表的结点中有两个指针prior和next，分别指向前驱结点和后继结点。  双链表中结点类型的描述： t
数据结构（1）-- 基础知识、顺序表、链表（单链表、单向循环链表、双向链表）
strLiusx的博客
02-23 491
顺序表的实现、链表、单向循环链表、双向链表的实现
数据结构：顺序表，链表，双向链表
m0_61350245的博客
08-12 836
顺序表，链表，双向链表
线性表——顺序表，单向链表和双向链表
小吴
01-17 1113
博客主页(4条消息) 小吴_小吴有想法_CSDN博客-笔记,java,leetcode领域博主 欢迎关注点赞收藏和留言 天道酬勤，勤能补拙，和小吴一起加油吧 17岁大一新生，水平有限，恳请各位大佬指点，不胜感激! 参考书籍《算法4》，学习视频：黑马程序员Java数据结构与java算法，全网资料最全数据结构+算法教程，154张java数据结构图_哔哩哔哩_bilibili 目录 线性表 顺序表 代码实现 时间复杂度 链表 单向链表 单向链表代码实现 双向链表 代码...
顺序表和链表04——双向链表
m0_61608447的博客
05-02 476
双向链表的实现
顺序表与双向链表
LiXingyue
08-18 135
System.arrayCopy:数组拷贝且指定源数组、目标数组等等 Arrays.copyOf：整个数组拷贝到新的数组 1.迭代器的两个作用： （1）为了统一接口的遍历方式： 顺序表还是链表，遍历方式是一致的，用户不需要关心内部实现（封装性） （2）可以删除元素 2.懒加载： 好处：节省空间，用的时候在申请 坏处：第一次用的时候耗费时间长 3.实现一个顺序表与双向链表 //List接口 publ...
顺序表和链表（包括双向链表）代码总结
qq_42031380的博客
11-09 199
顺序表的实现： public class MyArrayList { public int usedSize; public int[] elem; public final int CAPACITY = 10; public MyArrayList() { this.usedSize = 0; this.elem = new i...
单向链表和双向链表的优缺点
最新发布
03-22
单向链表和双向链表都是常见的链表数据结构，它们在存储和操作数据时有一些不同之处。 单向链表（Singly Linked List）是一种线性数据结构，它由一系列节点组成，每个节点包含一个数据元和一个指向下一个节点的指针...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值