数据结构 线性表的顺序存储和链式存储，以及基本操作、单链表例题

已于 2022-02-09 17:38:08 修改
阅读量983 收藏 7
点赞数 3
分类专栏： 笔记 数据结构 文章标签： 数据结构 链表 list
于 2021-10-29 22:37:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53334934/article/details/121042920
版权

一、线性表的存储表示

1、顺序表

线性表的顺序表示又称为顺序表。

顺序表的静态分配存储表示

//线性表的静态分配顺序存储结构
typedef int ElemType;
typedef  struct {      //顺序表的定义
	ElemType  elem[LISTSIZE];
	int   length;          //当前长度
}Sqlist;

顺序表的动态分配存储表示 

//线性表的动态分配顺序存储结构
#define LIST_INIT_SIZE 100  //初始分配量
#define LISTINCREMENT 10 //分配增量
typedef int ElemType;
typedef  struct {
	ElemType* elem;    // 存储空间基址
	int      length;   // 当前长度
	int      listsize;  // 当前分配的存储容量(以sizeof(ElemType)为单位)
} SqList;  // 俗称 顺序表


//线性表的初始化操作：elem=new ElemType[LIST_INIT_SIZE]
//或者elem=(ElemType*)malloc(sizeof(ElemType)*LIST_INIT_SIZE)

其中，线性表的初始化操作为：elem=new ElemType[LIST_INIT_SIZE]
或者elem=(ElemType*)malloc(sizeof(ElemType)*LIST_INIT_SIZE) 

2、线性链表

线性表的链接存储表示

最简单的链表为线性表，一般描述为

typedef int DataType;
typedef struct LNode {
	int data;
	struct LNode* next;
}LNode, * LinkList;

动态分配结点空间的语句

s= (LinkNode*)malloc(sizeof(LinkNode));  //s为指示链表结点存储地址的指针

其他形式的链表，如 循环链表

 

双向循环链表

 

二、线性表的基本操作

1、线性表的静态存储顺序表的基本操作

//初始化操作（创建一个空表）
void InitList(Sqlist& L) {
	L.length = 0;
}

//销毁操作
void DestroyList(Sqlist& L) {
	free(L.elem);
	L.length = 0;
}

//求表长
int GetLength(Sqlist& L) {
	return L.length;
}

//查找第i个元素（元素从1开始算）
ElemType GetElem(Sqlist& L, int i) {
	if (i < L.length) {
		return L.elem[i - 1];
	}
	return 0;
}

//查找已知元素位置（元素从1开始算）
int LocateElem(Sqlist& L, ElemType e) {
	for (int i = 0; i < L.length; i++) {
		if (L.elem[i] == e) {
			return i + 1;
		}
	}
	return 0;
}

//插入操作（将新元素e插入第i个元素前面）（元素从1开始算）
int InsertList(Sqlist& L, int i, ElemType e) {
	if (i <= L.length + 1) {
		for (int j = L.length; j > i - 1; j--) {
			L.elem[j] = L.elem[j - 1];
		}
		L.elem[i - 1] = e;
		L.length++;
		return 1;
	}
	return 0;
}

//删除操作（删除第i个元素）（元素从1开始算）
int DeleteList(Sqlist& L, int i) {
	if (i <= L.length) {
		for (int j = i - 1; j < L.length-1; j++) {
			L.elem[j] = L.elem[j + 1];
		}
		L.length--;
		return 1;
	}
	return 0;
}

//读取第i个元素（元素从1开始算）
ElemType PrintElem(Sqlist& L, int i) {
	if (i < L.length) {
		printf("%d\n", L.elem[i - 1]);
		return 1;
	}
	return 0;
}

2、线性表的动态存储顺序表的基本操作

//线性表的动态存储顺序表的基本操作
//初始化操作（创建一个空表）
void InitList(SqList& L) {
	L.elem = (ElemType*)malloc(sizeof(ElemType) * LIST_INIT_SIZE);
	L.length = 0;
	L.listsize = LIST_INIT_SIZE;
}

//销毁操作
void DestroyList(SqList& L) {
	free(L.elem);
	L.length = NULL;
	L.listsize = NULL;
}

//求表长
int GetLength(SqList& L) {
	return L.length;
}

//查找第i个元素（元素从1开始算）
ElemType GetElem(SqList& L, int i) {
	if (i < L.length) {
		return L.elem[i - 1];
	}
	return 0;
}

//查找已知元素位置（元素从1开始算）
int LocateElem(SqList& L, ElemType e) {
	for (int i = 0; i < L.length; i++) {
		if (L.elem[i] == e) {
			return i + 1;
		}
	}
	return 0;
}

//动态表扩充存储空间
void AddSqList(SqList& L) {
	int newSize;
	ElemType* newArray;
	newSize = LISTINCREMENT + LIST_INIT_SIZE;
	newArray = (ElemType*)malloc(sizeof(ElemType) * newSize);
	for (int i = 0; i < L.length; i++) {
		newArray[i] = L.elem[i];
	}
	L.elem = newArray;
	L.listsize = newSize;
}

//插入操作（将新元素e插入第i个元素前面）（元素从1开始算）
int InsertList(SqList& L, int i, ElemType e) {
	if (L.length == L.listsize) { 
		AddSqList(L); 
	}
	if (i <= L.length + 1) {
		for (int j = L.length; j > i - 1; j--) {
			L.elem[j] = L.elem[j - 1];
		}
		L.elem[i - 1] = e;
		L.length++;
		return 1;
	}
	return 0;
}

//删除操作（删除第i个元素）（元素从1开始算）
int DeleteList(SqList& L, int i) {
	if (i <= L.length) {
		for (int j = i - 1; j < L.length - 1; j++) {
			L.elem[j] = L.elem[j + 1];
		}
		L.length--;
		return 1;
	}
	return 0;
}

//读取第i个元素（元素从1开始算）
ElemType PrintElem(SqList& L, int i) {
	if (i < L.length) {
		printf("%d\n", L.elem[i - 1]);
		return 1;
	}
	return 0;
}

 3、单链表的基本操作

//单链表的基本操作
//初始化
void InitList(LinkList& L) {
	L= (LinkList)malloc(sizeof(LNode));//头指针
	L->next = NULL;
}

// 取第i个数据元素
int GetElem(LinkList& L, int i, int e) {
	//L是带头结点的链表的头指针，以e返回第i个元素
	LinkList p = L->next;
	int j = 1;//p指向第一个结点，j为计数器
	while (p && j < i) {
		p = p->next;
		j++;
	}
	if (!p) {
		return 0;
	}
	e = p->data;
	return e;
}

// 插入数据元素
int ListInsert(LinkList&L,int i,int e) {
	//将元素e插入第i个结点之前
	LinkList p = L;
	int j = 0;
	while (p && j < i - 1) {
		p = p->next;
		j++;
	}
	if (!p || j > i - 1) {
		return 0;
	}
	LinkList s = new LNode;
	if (s == NULL)return 0;
	s->data = e;
	s->next = p->next;
	p->next = s;
	return 1;
}

// 删除数据元素
int ListDelete(LinkList& L, int i) {
	//删除第i个结点
	LinkList p = L;
	int j = 0;
	while (p->next && j < i - 1) {
		p = p->next;
		j++;
	}
	if (!(p->next) || j > i - 1) {
		return 0;
	}
	LinkList q = p->next;
	p->next = q->next;
	return 1;
}

// 重置线性表为空表
int ClearList(LinkList& L) {
	free(L);
	InitList(L);
	return 1;
}

// 生成含 n 个数据元素的链表（尾插法）
void CreateList(LinkList& L, int n) {
	L= (LinkList)malloc(sizeof(LNode));
	LinkList rear = L;//设置尾指针
	for (int i = 0; i < n; i++) {
		rear->next= (LinkList)malloc(sizeof(LNode));
		rear = rear->next;
		scanf_s("%d", &(rear->data));
	}
}

//生成含 n 个数据元素的链表（头插法）
void CreateList_L(LinkList& L, int n) {
	LinkList p;
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;
	for (int i = n; i > 0; --i) {
		p = (LinkList)malloc(sizeof(LNode));
		scanf_s("%d", &(p->data));
		p->next = L->next;
		L->next = p;
	}
}//CreateList_L

//输出单链表L
void listPrint(LinkList& L)
{
	printf("单链表：");
	LNode* p = L;
	while (p->next != NULL)
	{
		printf("%d ", p->next->data);
		p = p->next;
	}
	printf("\n");
}

三、例题 

设计一个算法，顺序读出数组a[n]中的元素数值，建立一个带头结点的单链表，次序与a[n]相同

尾插法

void createListR(LinkList& list, DataType a[], int n) {
	//根据数组a[n]建立一个单链表，单链表各元素次序与a[n]各元素相同
	list = (LinkNode*)malloc(sizeof(LinkNode));  //创建头节点
	LinkNode* rear = list;   //设置尾指针
	for (int i = 0; i < n; i++) {      //尾插法
		rear->link = (LinkNode*)malloc(sizeof(LinkNode));  //为rear下一个位置分配空间
		rear= rear->link;
		rear->data = a[i];
	}
}

 设计一个算法，顺序读出数组a[n]中的元素数值，建立一个带头结点的单链表，次序与a[n]相反

头插法

void createListF(LinkList& list, DataType a[], int n) {
	//根据数组a[n]建立一个单链表，单链表各元素次序与a[n]各元素相反
	LinkList s;
	list=(LinkNode*)malloc(sizeof(LinkNode));  //创建头结点
	list->link = NULL;  //尾结点设置为NULL
	for (int i = 0; i < n; i++) {      //头插法
	s= (LinkNode*)malloc(sizeof(LinkNode));
	s->data = a[i];
	s->link = list->link;
	list->link = s;
	}
}

 单链表的输出

void listPrint(LinkNode* L)
{
	printf("单链表：");
	LinkNode* p = L;  //将头指针赋给p
	while (p->link != NULL)
	{
		printf("%d   ", p->link->data);  //输出单链表p->link的结点数据
		p = p->link;  //将p向后移一个位置
	}
	printf("\n");
}

找出单链表中最大值

void Max(LinkList L) {
	LinkList p;
	int max=0;
	for (p = L->link; p != NULL; p = p->link) {   //用p遍历链表
		if (max < p ->data) {
			max = p->data;
		}
	}
	printf_s("%d", max);
}

 计算单链表长度

void Length(LinkList& L) {
	LinkList p=L->link;
	int length = 0;
	while (p != NULL) {
		p = p->link; length++;
	}
	printf_s("%d", length);
}

 找出单链表倒数第k个元素

int SearchK(LinkList list, int k) {
	LinkList p, q; int count = 0;      //计数器赋初值
	for (p = q = list->link; p != NULL; p = p->link) {  //用遍历链表
		if (count < k)
			count++;      //计数器加一
		else
			q = q->link;    //在count>=k时开始移动
	}
		if (count < k)
			return 0;   //链表长度小于k查找失败
		else {
			printf("%d\n", q->data);
			return 1;   //查找成功
		}
}

薄荷°
关注
专栏目录
【考研数据结构题型分类讲解练习】1-1线性表--选择题--习题篇
Anthony_4926
12-28 5239
题型一：选择合理的存储结构 1. 线性表的顺序存储结构是一种(）【北京理工大学2006五、3 (1分)】答案讲解直达 A.随机存取的存储结构 B.顺序存取的存储结构 C.索引存取的存储结构 D. Hash存取的存储结构 2.能在0(1)时间内访问线性表的第i个元素的结构是( ) 。【电子科技大学2011一、2(2分)】 A.顺序表 B.单链表 C.单向循环链表 D.双向链表 3.·若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算,则利用( )存储方式最节省时间。【哈尔滨工业大学
算法与数据结构【30天】集训营——线性表之链式表的表示与实现及顺表与链表比较（04）
迷茫与徘徊只会让你陷入绝境，欢迎私信博主，带你开始提升变现价值！
08-07 725
线性表的链式存储又称单链表， 它是指通过一组任意的存储单元来存储线性表中的数据元素。为了建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息外， 还需要存放一个指向其后继的指针。//定义单链表结点类型 ElemType data;//数据域 struct LNode * next;/ 指针域 } LNode , * LinkList;增加头结点的单链表① 由于第一个数据结点的位置被存放在头结点的指针域中，因此在链表的第一个位置上的操作和在表的其他位置上的操作一致，无须进行特殊处理。...
线性链表和顺序表的基本操作
escFAJ的博客
08-10 580
线性链表和顺序表的基本操作 一、实验目的： 线掌握线性表的逻辑特性以及在计算机内的两种存储结构，线性链表和顺序表存储结构下基本操作的实现，会灵活应用线性表结构解决某些实际问题。 二、实验内容： 1，线性表顺序存储结下的基本操作的实现（初始化，赋值、取值、插入、删除归并等）。 2，线性表链式存储结下的基本操作的实现（初始化，赋值、取值、插入、删除归并等）。 三、实验要求： 在本题下面提交源程序和实验运行结果截图。 上交纸质版实验报告和电子版实验报告。 四、源程序及注释 1，线性表顺序存储结下的基本操作的实
lc 19.删除链表的倒数第N个节点（链表，***快慢指针）
sankuaizhuobu的博客
10-29 193
官方题解https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/solution/shan-chu-lian-biao-de-dao-shu-di-nge-jie-dian-b-61/ 我看的代码https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/comments/105722 class Solution { public: Li..
顺序表的链式存储及操作
m0_37546257的博客
10-16 717
相比于顺序存储，链式存储的优点有以下几点： 1.插入和删除操作效率高于顺序表，当数据规模越大时，效率提高越明显； 2.链式存储不需要大片连续内存空间，每个数据结点占据很少一段内存通过指针将其串起来，从而达到灵活使用的目的； 当然链式存储也有不足之处： 当遍历顺序表中的元素时需要从链表头部依次查找才能定位到要查询的数据结点； 实现代码： seq_link.h #ifndef _SEQ_LINK_H #define _SEQ_LINK_H #include <stdio.h> #include &l
线性表的顺序存储结构和链式存储结构及二者的简单操作（C，C++混用）
qq_35593460的博客
11-12 1535
线性表的顺序存储结构和链式存储结构及二者的简单操作（C，C++混用） 一、前言： ​ 在学数据结构的时候，第一次上机实验，老师让我们实现线性表的顺序存储结构和链式存储结构及其简单操作，看着就脑阔疼。书上的代码吧，都是伪代码，照着敲出来n多报错（我们用的是清华大学出版社严蔚敏、陈文博编著的《数据结构及应用算法程序（修订版）》，书挺好的，就是有些地方不太照顾初学者。反正就是看着脑瓜子嗡嗡的，但搞懂了之后满满的都是成就感，让人又爱又恨，感兴趣的小伙伴可以看看）；上网搜前人的成果吧，无一例外都报错七八
【线性表】顺序存储、链式存储的实现及操作
innovatethinking Blog
09-24 3107
一、线性表的定义：(1)概念定义：用数据元素的有限序列表示叫做线性表；线性表中数据元素的类型可以为简单类型，也可以为复杂类型。许多实际应用问题所涉的基本操作有很大相似性，不应为每个具体应用单独编写一个程序。从具体应用中抽象出共性的逻辑结构和基本操作（抽象数据类型），然后实现其存储结构和基本操作。(2)类型定义：首先抽象出ADT List表的结构，在C/C++中一般都是采用struct来实现的。基本操
2.数据结构与算法--线性表(定义)，链式存储结构（单链表的创建-头插法-尾插法）
qq_27158571的博客
12-23 1257
线性表的链式存储结构 节点定义 单链表示意图
MOOC_浙大数据结构_线性表，堆栈，队列的（顺序存储与链式存储)
sxycylq的博客
09-14 209
线性表 数据结构中最常见的方法：数组存储/链表存储 线性表，由同类型数据元素构成的有序序列的线性结构 特点： 表中元素的个数—线性表的长度 表中没有元素时—空表 表起始的位置—表头 表结束的位置—表尾 数据对象集： 线性表时由n个元素组成的有序序列 主要操作： 初始化空表 查找位序 查找初次出现位置 在位序前插入新元素 删除指定位序的元素 返回表的长度 线性表顺序存储：利用数组的连续存储空间顺序存放线性表的各元素 #include<stdio.h> #include<iostrea
3. 线性表（1）
dugudaibo的博客
01-26 758
本文是《小甲鱼数据结构》的学习笔记，对视频课程中的相关知识进行总结。   欢迎大家在评论区多多留言互动~~~~ 1. 线性表的定义   线性表是由零个或多个数据元素组成的有限 序列。   这里需要强调几个关键的地方   (1) 首先他是一个序列，就是元素之间有顺序；   (2) 若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他的元素都只有一个前驱和后继；
数据结构笔记（四）顺序表和链表的基本操作
weixin_45541911的博客
08-20 505
线性表 线性表又分为顺序储存和链式储存，分别称为顺序表和链表。 顺序表 在计算机中申请一块连续的空间，将元素按存入,是一种随机存取的方式，这种方式可以随时读取，其时间复杂度为O(1)，但需要做增删操作时，需要移动大量元素，时间复杂度是O（n）。因为是连续的空间，因此会造成空间浪费或溢出的现象。 删除顺序表的第 i 个元素时，需要移动 n - i 个元素； 插入到第 i 个位置时，需要移动 n - i + 1个元素。 顺序表有静态分配与动态分配，这里记录最常用的动态分配 #include<stdlib
python线性表链式存储实现_Python实现--线性表-顺序存储结构--的基本运算
weixin_34652580的博客
01-14 441
class SequenceList():def __init__(self):self.SeqList = []def createSequenceList(self):element = input('please input a numer and enter # ensure:')while element != '#':self.SeqList.append(int(element))e...
使用只有表尾指针或只有表头指针的单循环链表的情况
热门推荐
PM伟少
07-03 1万+
使用只有表尾指针没有表头指针： 循环单链表指的是最后节点的指针域指向表头节点，如果要删除第一个元素，只需要通过表尾指针找到第二个节点，然后将最后节点的指针指向第二个节点，就将第一个元素删除了； 单链表指的是最后节点的指针域指向表头节点，如果要删除第一个元素，只需要通过表尾指针找到第二个节点，然后将最后节点的指针指向第二个节点，就将第一个元素删除了； 在最后一个元素后面插入新元素时，先找到...
线性表顺序存储算法题
adong6561975的博客
05-14 781
1、从线性表中删除具有最小值的元素（假设唯一）并由函数返回被删除元素的值，空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并保存退出。 算法思想：搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填补空出的原最小值元素的位置。 代码如下： bool Del_Min(sqList &L, ElemType &value) { //删除顺序表L中最小值元素结点，并通过引用型参数value返回其值 //若删除成功，则返回tr...
单链表及常见算法题
Ronz 的博客
12-23 2075
一、链表概述 1.1 链表介绍 链表（ Linked List ），别名链式存储结构或单链表，是一种常见的基础数据结构，用于存储逻辑关系为 “一对一” 的数据。链表是线性表的一种，但是它并不像顺序表一样是连续存储在内存中的。链表的各个结点散布在各个内存区域，在每一个结点中都存放下一个结点的地址。 单链表在内存中是如下存储的： 其中：data 域存放的是本结点的数据，next 域存放的是下一个结点的地址。 通过上面的图，我们可以得到链表的几个特性： 链表是以结点的方式来存储的，是链式存储； 每一
数据结构之顺序存储与链式存储
wahkim的博客
11-25 1万+
http://www.itongji.cn/detail?type=1121 https://blog.csdn.net/qq_38378384/article/details/80430396 定义 线性表，全名为线性存储结构。 线性表是n个数据特性相同的元素的组成有限序列，是最基本且常用的一种线性结构(线性表，栈，队列，串和数组都是线性结构），同时也是其他数据结构的基础。具有“一对一”逻辑关系的数据，最佳的存储方式是使用线性表。 特点 是一个有限的序列 可以是有序的也可以是无序的。 线性表的开始元素没
《数据结构》线性表：链式存储结构实现示例代码二（插入、删除、查找）
明哥的专栏
08-16 4652
#include //引用输入输出流库函数的头文件 //#ifndef LinkList_H //#define LinkList_H /*************************************/ /***** 声明模板类 *****/ /***** 可以单独放在一个头文件中 *****/ /************************
学数据结构（二）线性表（链式存储）（线性表应用和典型例题）（实际操作）
登登的博客 是温馨的小屋。
05-16 1736
以后关于线性表的相关应用和其他的相关例题都会在此更新，可以用来考试，准备工作，学习算法思想等等！
【数据结构】顺序表的链式存储结构（单链表，C语言版）
pcdd's blog
04-20 4540
【代码】【数据结构】顺序表的链式存储结构（单链表，C语言版）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值