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

最新推荐文章于 2022-08-12 04:12:33 发布
最新推荐文章于 2022-08-12 04:12:33 发布
阅读量699 收藏
点赞数
分类专栏： 数据结构基础 文章标签： 顺序表 链表 双向链表 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);
}

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

顺序表、链表、双向循环链表
wolfGuiDao的博客
10-23 1328
顺序表、链表、双向循环链表 SeqList.h #pragma once #include<stdio.h> #define ListSize 100 //线性表的最大长度 typedef int DataType; typedef struct { DataType data[ListSize]; //用数组存储线性表中的元素 DataType length; ...
单向链表改双向链表
宇宙观光巴士站
12-05 2812
单向链表改双向链表 -数据结构题目 （原题来自严蔚敏老师教材习题册2.32） 题目：已知有一个单向循环链表，其每个结点中含三个域：prior,data和next，其中data为数据域，next为指向后继结点的指针域，prior也为指针域，但它的值为空（NULL），试编写算法将此单向循环链表改为双向循环链表，即使prior成为指向前驱结点的指针域。 算法思想：先建立一个单链表，然后写一个函数，将prior指针指向它的前驱元素即可完成修改。 c++代码如下： #include <iostream>
顺序表与双向链表
LiXingyue
08-18 152
System.arrayCopy:数组拷贝且指定源数组、目标数组等等 Arrays.copyOf：整个数组拷贝到新的数组 1.迭代器的两个作用： （1）为了统一接口的遍历方式： 顺序表还是链表，遍历方式是一致的，用户不需要关心内部实现（封装性） （2）可以删除元素 2.懒加载： 好处：节省空间，用的时候在申请 坏处：第一次用的时候耗费时间长 3.实现一个顺序表与双向链表 //List接口 publ...
顺序表和链表（包括双向链表）代码总结
qq_42031380的博客
11-09 237
顺序表的实现： public class MyArrayList { public int usedSize; public int[] elem; public final int CAPACITY = 10; public MyArrayList() { this.usedSize = 0; this.elem = new i...
线性表——顺序表，单向链表和双向链表
小吴
01-17 1195
博客主页(4条消息) 小吴_小吴有想法_CSDN博客-笔记,java,leetcode领域博主 欢迎关注点赞收藏和留言 天道酬勤，勤能补拙，和小吴一起加油吧 17岁大一新生，水平有限，恳请各位大佬指点，不胜感激! 参考书籍《算法4》，学习视频：黑马程序员Java数据结构与java算法，全网资料最全数据结构+算法教程，154张java数据结构图_哔哩哔哩_bilibili 目录 线性表 顺序表 代码实现 时间复杂度 链表 单向链表 单向链表代码实现 双向链表 代码...
数据结构：顺序表，链表，双向链表
m0_61350245的博客
08-12 922
顺序表，链表，双向链表
Python单向链表和双向链表原理与用法实例详解
09-20
在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只包含一个指向下一个节点的引用。在单向链表中，遍历只能从头节点开始，按顺序访问每个节点，无法...
C语言自学链表，单向链表，双向链表，适合新手学习。
06-18
本资源提供的是针对初学者设计的链表学习材料，包括单向链表和双向链表的实现。下面将详细讲解这两种链表的数据结构及其操作。 1. **单向链表**： 单向链表是一种线性数据结构，每个节点包含两部分：数据域和指针...
航班管理系统 单向顺序链表 双向非循环顺序链表
07-04
1.航班管理员可以——添加航班——查询航班信息——修改航班信息——查询乘客信息（管理员登陆口令：123456） 2.乘客可以——查询航班信息——订票——退票 3.航班链表为单向顺序链表，乘客链表为双向非循环顺序链表
顺序表和链表
passion
08-03 3083
顺序表和链表的简单介绍和实现
顺序表和链表04——双向链表
m0_61608447的博客
05-02 504
双向链表的实现
c++顺序表与双向链表实现
zhang1308299607的博客
07-22 467
之前实现过c语言版本的顺序表和单向链表，现在实现c++版本的顺序表和双向链表： 再来看一下顺序表，单链表和双向链表的区别： 顺序表的c++实现： #define _CRT_SECURE_NO_DEPRECATE 1 #include #include #include using namespace std; typedef int Datatype; class SeqList
顺序表--单链表,双向链表的c语言的基本操作
qq_43610614的博客
10-14 297
链表由各个结点链接而成 结点=数据域+指针域（数据域存储存储数据，指针域存储下一结点的地址） 头指针指向头结点，头结点不存储数据，首元结点为第一个保存数据的结点 下面是单链表用c语言表示的代码 typedef struct Lnode{ //声明结点的类型和指向结点的结点类型 Elemtype data; //结点的数据域，Elemtype为自己使用typedef定义的数据类型 struc...
线性表--顺序表、单链表、双链表 总结
萧西朗的博客
05-07 377
线性表--顺序表、单链表、双链表 基础操作总结 // 栈、队列与顺序表.cpp : 此文件包含 "main" 函数。 #include <iostream> #include "stdio.h" #define MaxSize 50 typedef int ElemType; typedef struct {//静态顺序线性表定义 ElemType data[Ma...
顺序表-链表-双向循环链表。
sinat_42400020的博客
05-19 247
1.顺序表 #pragma once #include"common.h" #define SEQLIST_DEFAULT_SIZE 10 typedef struct SeqList { ElemType* base; size_t capacity;//容量 size_t size;//实际大小 }SeqList; static bool _Inc(SeqList* pst); //增加成功返回 true, 失败返回false void SeqListInit(SeqList* pst);
顺序表之单向链表
qq_40282585的博客
05-16 166
这个应该没什么难度，源码如下，供大家参考//exp2-2.c ---------------- 单链表 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define OK 1 #define ERROR 0 //===================ADT 单链表 结构说明 ======== typedef int ElemType; ...
循环链表，双链表，顺序表和链表的比较
zh23862691的专栏
10-03 2543
循环链表：在单链表中，如果将终端结点的指针域由空指针改为指向头结点，就使得整个单链表形成一个环，这种头尾相接的单链表称为循环单链表，简称循环链表。 在用头指针指示的循环链表中，找到开始结点的时间是O（1）,然而要找到终端结点，则需从头指针遍历整个循环链表，其时间是O（n）。 在很多实际问题中，操作时在表的首或尾进行，此时头指针指示的循环链表就显得不够方便，如果改用指向终端结点的尾指针（rear
顺序表专题(2)——单向链表
Jakob_Hu的博客
05-17 217
单向链表概念节点的实现单链表的操作单链表实现单向链表与顺序表对比空间对比时间对比 概念 单向链表也称单链表，是链表中最简单的形式，每个节点包含两个域（两个属性），一个元素域和一个链接域，其中，链接域指向下一个节点的地址，而最后一个节点的链接域指向的是一个空值。 节点的实现 以Python代码实现， class SingleNode: """单链表节点""" def __init__(self...
C++方式封装顺序表、单链表和双向链表
Elay0701的博客
08-26 507
1.顺序表 Seqlist.h #pragma once typedef int DataType; class Seqlist { public: Seqlist()//构造 :_array(NULL) , _size(0) , _capacity(0) {} Seqlist(const Seqlist& s)//拷贝构造 { _array = (Da
JavaScript实现链表：单向链表与双向链表解析
"本文主要介绍了JavaScript中的数据结构与算法中的链表，包括链表的基本概念、单向链表和双向链表的实现。" 在计算机科学中，数据结构是组织和存储数据的方式，而算法是解决问题的具体步骤。链表作为一种重要的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值