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

已于 2022-02-09 17:38:08 修改
阅读量979 收藏 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;   //查找成功
		}
}

薄荷°
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法理论复习
04-12
线性表可以采用顺序存储（数组）或链式存储（链表）。链表分为单链表、双链表和循环链表，每种都有其特定的操作优势。线性表的操作主要包括插入、删除、查找等，这些操作在编程中极其常见。 最后，PAT例题是一个...
第四周项目3——单链表应用（1）
qxl1057223919的博客
09-22 361
问题： /* * Copyright (c)2016,烟台大学计算机与控制工程学院 * All rights reserved. * 文件名称：项目3.cpp * 作 者：秦绪龙 * 完成日期：2016年9月22日 * 版 本 号：v1.0 *问题描述：设计一个算法，将一个带头结点的数据域依次为a1，a2，…，an（n≥3） 的单链表
数据结构——创建一个带头节点的单链表(C语言)
weixin_73849400的博客
01-20 6859
基础的单链表的构建，以及前插法、后插法在输入数据时的应用。还有一些细小的不同引发的非法访问及其解决方法。
SDUT数据结构线性表作业（1） 回文验证算法
qq_62257987的博客
03-20 154
算法设计题（要求将代码复制上来，并将运行结果截图上传到程序下面） 1、设计一个算法，顺序读取数组A[n]中的元素的数据值，建立一个带有头结点的单链表，使单链表中各元素的次序与A[n]中各元素的次序相同。 2、设有带头结点的单链表list，设计一个算法，判断它是否中心对称（即回文）
c++使用单向链表存储一组有序数据_数据结构线性表（二）
weixin_34723270的博客
12-29 819
1、 线性表的链式存储结构1、线性表的链式存储结构—链表(1)如果每个结点只设置一个指向其后继结点的指针成员，这样的链表称为线性单向链接表，简称单链表。(2)如果每个结点中设置两个指针成员，分别用以指向其前驱结点和后继结点，这样的链表称之为线性双向链接表，简称双链表。2、单链表每个结点为LinkNode类对象，包括存储元素的数据列表data和存储后继结点的指针属性next。单链表类LinkList...
建立一个带头结点的元素值递增有序的单链表(边插入边排序) c语言
qq_46234209的博客
06-21 4168
建立一个带头结点的元素值递增有序的单链表(边插入边排序) c语言 //建立一个带头结点的元素值递增有序的单链表 #include"stdio.h" #include"stdlib.h" typedef struct node { int data; struct node *next;//struct node *类型，指向node本身; }link; link *paixu(link * head) { link *t,*p,*q; int x; t=(link *)malloc(sizeo
数据结构第2章典型例题解析.doc
09-26
总之，线性表的存储结构选择应根据主要操作来优化，顺序存储适合随机访问，链式存储适合频繁的插入和删除，静态链表则兼顾两者，但牺牲了部分随机访问的效率。理解这些基本概念和操作的性能特点，对于设计高效的数据...
数据结构上机例题与答案.doc
10-04
这里我们分析的是关于数据结构的一些上机练习题和答案，涉及链表、线性表的存储结构以及插入操作。 首先，我们需要理解几个关于链表的基本概念： 1. 头指针变量和头指针：这两个术语通常指的是同一个东西，即指向...
专升本《数据结构》模拟题试卷.pdf
11-02
1. 线性表：涉及线性表的定义及其基本操作，如数组实现的线性表（顺序表），以及链式存储结构如单链表、循环链表和双向链表的操作和特性。此外还考察了线性表的插入、删除、查找等操作的算法复杂度。 2. 栈和队列：...
数据结构第四章链表作业（C++）
o55str的博客
10-14 1292
以带表头结点的单链表为例，实现的几个函数功能： (1) 建立函数create：根据一维数组a[n]建立一个单链表，使单链表中各元素的次序与a[n]中各元素的次序相同，要求该程序的时间复杂性为O(n)。（此题函数已经提供，不用做） (2) 定位函数locate：在单链表中寻找第i个结点。若找到，则函数返回第i个结点的地址；若找不到，则函数返回NULL。 (3) 求最大值函数max：通过一趟遍历在单链表中确定值最大的结点。 (4) 统计函数number：统计单链表中具有给定值x的所有元素。（此题可不做.
[数据结构]线性表链式结构及基本操作
weixin_43717520的博客
04-06 1787
链表
【数据结构】顺序表的链式存储结构（单链表，C语言版）
pcdd's blog
04-20 4535
【代码】【数据结构】顺序表的链式存储结构（单链表，C语言版）
线性表的顺序存储结构和链式存储结构
qq_64481855的博客
09-05 2521
学习线性表的顺序存储和链式存储
线性表顺序存储算法题
adong6561975的博客
05-14 778
1、从线性表中删除具有最小值的元素（假设唯一）并由函数返回被删除元素的值，空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并保存退出。 算法思想：搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填补空出的原最小值元素的位置。 代码如下： bool Del_Min(sqList &L, ElemType &value) { //删除顺序表L中最小值元素结点，并通过引用型参数value返回其值 //若删除成功，则返回tr...
数据结构链表的初始化插入删除_算法设计：数据结构-线性表
weixin_39760065的博客
11-22 273
(一)线性表的概念线性表是具有相同特性元素的有限序列。该序列中所含元素的个数叫做线性表的长度，用n表示(n>=0)，注意，n可以等于0表示是一个空表注意：不同的线性表的数据元素可以不同，但对于同一线性表，各数据元素必须具有相同的数据类型，即同一线性表中各数据元素具有相同的类型，每个数据元素的长度形同线性表数据结构具有以下特征：1、有且只有一个首元素2、有且只有一个尾元素3、除尾元素之外，其余...
线性表（顺序表）的初始化，取值，查找，插入及删除（c++）
m0_74472474的博客
09-11 6993
顺序表中的基本操作以及描述（基本操作包括对线性表进行初始化，取值，查找元素，插入元素以及删除元素)
链表操作练习
fireflylane的博客
09-27 2021
综合题 本小题请务必重视，综合了各种链表操作（各种考试考题），可以做成一个比较完整的工程，请设计测试程序进行测试，务必自己编写代码。 1．针对带表头结点的单链表，试编写下列函数。 (1) 建立函数create：根据一维数组a[n]建立一个单链表，使单链表中各元素的次序与a[n]中各元素的次序相同，要求该程序的时间复杂性为O(n)。 (2) 定位函数locate：在单链表中寻找第i个结点。若找到，则...
初学数据结构——从零开始的数据结构学习总结篇（线性表）
Lazy_ChessPlayer的博客
04-10 966
前言 简介： 线性表是一种最简单也最常用的数据结构，它包括顺序表和链表两种实现方式。 在这篇博客中，我将介绍线性表的定义、特点、操作以及它们之间的优缺点和比较。我希望通过这篇博客，能够帮助大家更好地理解和掌握线性表这一重要的数据结构。 注： 本博客为本人在学习数据结构路途上的知识整理，如觉得对有你有所帮助，还希望不要吝啬你的赞，整理知识点是真的很累|*´Å`)ﾉ。由于博主只是一名大一新生，在文章难免会出现错误，还希望指正。如果想要转载，附上链接就行。 本文中的颜色标记 红色部分为重点内容 蓝
线性表基本操作——初始化、插入、删除、查找
最新发布
m0_74457303的博客
11-16 63
【代码】线性表基本操作——初始化、插入、删除、查找。
数据结构线性表详解：顺序与链式存储
链式线性表分为单链表和双向链表，单链表每个节点只包含指向下一个元素的指针，而双向链表则包含指向前后元素的两个指针。 在实际应用中，线性表广泛用于各种场景，如文件系统、数据库索引、表达式求值等。例如，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值