数据结构———线性表（考研：第二章）

最新推荐文章于 2024-04-20 21:43:58 发布
最新推荐文章于 2024-04-20 21:43:58 发布
阅读量459 收藏 4
点赞数
分类专栏： 考研资料整理 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L093117l/article/details/124363822
版权

数据结构——线性表（考研）


知识框架：
在这里插入图片描述

一、线性表的基本概念

1.线性表的定义
线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长。

//静态分配存储空间
#define MaxSize 10
typedef struct {
	int data[MaxSize];
	int length;
}SqList;

//动态分配存储空间
typedef struct {
	int *data;
	int MaxSize, length;
}SeqList;

2.线性表的基本操作
InitList(&L):初始化表。构造一个空的线性表。

//静态初始化
void initList(SqList & L) {
	for (int  i = 0; i <MaxSize; i++)
		L.data[i] = 0;
	L.length = 0;
}

//动态分配内存空间初始化
void initList(SeqList& L) {
	L.data = (int*)malloc(sizeof(int) * InitSize);
	L.length = 0;
	L.MaxSize = InitSize;
}

Length（L）：求表长。返回线性表L的长度，即L中数据元素的个数
LocateElem（L，e）：按值查找操作。在表L中查找具有给定关键值的元素

int LocatElem(SqList L,int e) {
	for (int i = 0; i < L.length; i++)
		if (L.data[i]==e)
			return i + 1;
	return 0;
}

GetElem（L，i）：按位查找操作。获取表L中第i个位置的元素的值

int GetElem(SqList L, int i) {
	return L.data[i - 1];
}

ListInsert（&L，i，e）：插入操作。在表L中的第i个位置上插入指定元素e

bool ListInsert(SqList &L, int i, int e) {
	if (i<1 || i>L.length + 1) {
		printf("该位置不可以插入元素\n");
		return false;
	}
		
	if (L.length >= MaxSize) {
		printf("存储空间已满，不可以再插入元素\n");
		return false;
	}

	for (int j=L.length;j>=i; i--)
		L.data[j] = L.data[j - 1];
	L.data[i - 1] = e;
	L.length++;
	return true;
}

ListDelete（&L，i，&e）：删除操作。删除表中第i个位置的元素，并用e返回删除元素的值

bool ListDelete(SqList &L,int i,int & e) {
	if (i<1 || i>L.length) {
		printf("该位置没有元素可以删除\n");
		return false;
	}
	e = L.data[i-1];
	for (int j = i; j < L.length; i++)
		L.data[j-1] = L.data[j];
	L.length--;
	return true;
}

PrintList（L）：输出操作。按前后顺序输出线性表L的所有元素值。
Empty（L）：判空操作。若L为空表，则返回true，否则返回false
DestroyList（&L）：销毁操作。销毁线性表，并释放线性表L所占用的内存空间。

二、线性表的实现

1.顺序存储

顺序表的定义：线性表的顺序存储又称顺序表。 顺序表的特点是表中元素的逻辑顺序与物理顺序相同。

顺序表上基本操作的实现：
（1）插入操作

//插入函数 位置i插入数据 i及之后元素后移  1=<i<=length+1 
bool InsertList(SqList& L, int i, int e)
{
	if (i<1 || i>L.length + 1) //判断位置是否有效
	{
		printf("位置无效！！！\n");
		return false;
	}
	if (L.length >= MaxSize)//判断存储空间是否已满
	{
		printf("当前存储空间已满！！！\n");
		return false;
	}
	for (int j = L.length; j >= i; j--)//位置i及之后元素后移
	{
		L.data[j] = L.data[j - 1];
	}
	L.data[i - 1] = e;
	L.length++;
	for (int i = 0; i < L.length; i++)
		cout << L.data[i] << " ";
	return true;
}

（2）删除操作

//删除函数 删除位置i的元素 i之后的元素依次前移
bool  ListDelete(SqList& L, int i)
{
	if (i<1 || i>L.length)
	{
		printf("位置无效！！！\n");
		return false;
	}
	for (int j = i; j <= L.length - 1; j++)//位置i之后元素依次前移覆盖
	{
		L.data[j - 1] = L.data[j];
	}
	L.length--;
	for (int i = 0; i < L.length; i++)
		cout << L.data[i] << " ";
	return true;
}

（3）按值查找（顺序查找【注：也可以使用其他的查找方法】）

//查找函数 按位置从小到大查找第一个值等于e的元素 并返回位置
int LocateElem(SqList L, int e)
{
	for (int i = 0; i < L.length; i++)//从低位置查找
		if (L.data[i] == e)
			return i + 1;
	return 0;
}

总代码：

#include<iostream>
#include <malloc.h>
#define MaxSize 50

using namespace std;

typedef struct {
	int data[MaxSize];
	int length;
}SqList;


int InitList(SqList& L)
{
	memset(L.data,0,sizeof(L));//初始化数据为0
	L.length = 0;                //初始化长度为0
	return 0;
}
//创建顺序表函数 初始化前n个数据
bool CreateList(SqList& L, int n)
{
	if (n<0 || n>MaxSize)false;//n非法
	for (int i = 0; i< n; i++)
	{
		cin >> L.data[i];
		L.length++;
	}
	cout << "顺序表如下所示：" << endl;
	for (int i = 0; i < n; i++)
		cout<<L.data[i]<<" ";
	return true;  
}
//插入函数 位置i插入数据 i及之后元素后移  1=<i<=length+1 
bool InsertList(SqList& L, int i, int e)
{
	if (i<1 || i>L.length + 1) //判断位置是否有效
	{
		printf("位置无效！！！\n");
		return false;
	}
	if (L.length >= MaxSize)//判断存储空间是否已满
	{
		printf("当前存储空间已满！！！\n");
		return false;
	}
	for (int j = L.length; j >= i; j--)//位置i及之后元素后移
	{
		L.data[j] = L.data[j - 1];
	}
	L.data[i - 1] = e;
	L.length++;
	for (int i = 0; i < L.length; i++)
		cout << L.data[i] << " ";
	return true;
}
//删除函数 删除位置i的元素 i之后的元素依次前移
bool  ListDelete(SqList& L, int i)
{
	if (i<1 || i>L.length)
	{
		printf("位置无效！！！\n");
		return false;
	}
	for (int j = i; j <= L.length - 1; j++)//位置i之后元素依次前移覆盖
	{
		L.data[j - 1] = L.data[j];
	}
	L.length--;
	for (int i = 0; i < L.length; i++)
		cout << L.data[i] << " ";
	return true;
}
//查找函数 按位置从小到大查找第一个值等于e的元素 并返回位置
int LocateElem(SqList L, int e)
{
	for (int i = 0; i < L.length; i++)//从低位置查找
		if (L.data[i] == e)
			return i + 1;
	return 0;
}

int main() {
	SqList L;	//定义顺序表L
	InitList(L);	//初始化顺序表

	int n;
	cout << "请输入数组的大小n：" << endl;
	cin >> n;
	cout << "请输入数组的元素：" << endl;
	CreateList(L,n);	//创造顺序表，即给顺序表中的元素赋值
	cout << endl;

	cout<< "插入操作：请输入位置i和数值e" <<endl;
	int i, e;
	cin >>i>>e;
	InsertList(L, i, e);

	cout << endl;
	cout << "删除操作：请输入你要删除的位置i：" << endl;
	int i1;
	cin >> i1;
	ListDelete(L, i1);

	cout << endl;
	cout << "查找操作：请输入你要查找的元素值e：" << endl;
	int e1;
	cin >> e1;
	cout<<LocateElem(L, e1)<<endl;
	return 0;
}

截图：
在这里插入图片描述

2.链式存储

（1）单链表

线性表的链式存储又称为单链表。
它是通过一组任意的存储单元来存储线性表中的数据元素。为了建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息外，还需要存放一个指向其后继的指针。

引入头结点的两个优点：
①：由于第一个数据结点的位置被存放在头结点的指针域中，因此在链表的第一个位置上的操作和在表的其他位置上的操作一致，无需进行特殊处理
②：无论链表是否为空，其头指针都指向头结点的非空指针（空表中头结点的指针域为空），因此空表和非空表的处理也得到了统一。

1.采用头插法建立单链表：

//头插法建立单链表
LinkList List_HeadInsert(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;
	LNode* s;						
	scanf("%d", &x);
	while (x != 9999) {
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		s->next = L->next;
		L->next = s;
		scanf("%d", &x);
	}
	return L;
}

2.采用尾插法建立单链表：

//尾插法建立单链表
LinkList List_TailInsert(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));	
	LNode* s, * r = L;						//r为表尾指针
	scanf("%d", &x);
	while (x != 9999) {
		s= (LNode *)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf("%d", &x);
	}
	r->next = NULL;
	return L;
}

3.按序号查找结点值：

//按位查找(不带头结点)
LNode* GetElem(LinkList L, int i) {
	LNode* p = L->next;
	int j = 1;
	if (i == 0)
		return L;
	if (i < 1)
		return NULL;
	while (p!=NULL||j<i)
	{
		p = p->next;
		j++;
	}
	return p;
}

//按位查找(带头结点)
LNode* GetElem(LinkList L, int i) {
	if (i < 0)
		return NULL;
	LNode* p = L;
	int j = 0;
	while (p != NULL || j < i)
	{
		p = p->next;
		j++;
	}
	return p;
}

4.按值查找表结点

//按值查找
LNode* LocatElem(LinkList L,int e) {
	LNode* p = L->next;
	while (p!=NULL&& p->data!=e)
		p = p->next;
	return p;
}

5.插入结点操作

//插入操作（不带头结点）
bool ListInsert2(LinkList& L, int i, int e) {
	if (i < 1)
		return false;
	if (i==1)
	{
		LNode *s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		s->next = L;
		L = s;
		return true;
	}
	LNode* p = L;
	int j = 1;
	while (p != NULL || j < i - 1)
	{
		p = p->next;
		j++;
	}
	if (p == NULL)
		return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//尾插入(由于是在结点的后面插入元素，所以不需要考虑是否有头结点)
bool InsertNextNode(LNode* p, int e) {
	if (p == NULL)
		return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL)
		return false;//内存分配失败
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//头插入(有头结点 虚假的前插入)
bool InsertPriorNode(LNode *p, int e) {
	if (p == NULL)
		return false;
	LNode *s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL)
		return false;//内存分配失败
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;
	return true;
}

6.删除结点操作

//删除操作
//带头结点删除
bool ListDelete1(LinkList &L,int i, int e) {
	if (i<1)
		return false;
	LNode *p = L;
	int j = 0;
	while (p == NULL || j < i - 1) {
		p = p->next;
		j++;
	}
	if (p == NULL||p->next==NULL)
		return false;
	LNode* q = p->next;
	e = q->data;
	p->next = q->next->next;
	free(q);
	
	return true;
}

//不带头结点删除
bool ListDelete2(LinkList &L, int i, int e) {
	if (i < 1)
		return false;
	LNode* p = L;
	int j = 0;
	while (p == NULL || j < i - 1) {
		p = p->next;
		j++;
	}
	if (p == NULL || p->next == NULL)
		return false;
	if (i == 1)
		L = L->next;
	return true;
}

7.求表长操作

（2）双链表

单链表结点中只有一个指向其后继的指针，使得单链表只能从头结点以此顺序往后遍历。
双链表有两个指针prior和next，分别指向其前驱结点和后继结点

1.双链表的插入操作

2.双链表的删除操作

（3）循环链表

1.循环单链表 循环单链表与单链表的区别是：表中的最后一个结点的指针不是NULL，而该为指向头结点，从而整个链表形成一个环。
2.循环双链表 循环双链表与双链表同循环单链表与单链表的关系

（4）静态链表（借助数组实现）

静态链表借助数组来描述线性表的链式存储结构，结点也有数据域data和指针域next，与其他链表中的指针不同的是，这里的指针是结点的相对地址（数组的下标），又称游标。和顺序表一样，静态链表也要预先分配好一块连续的内存空间。

//静态链表
#define MaxSize 10
typedef struct
{
	int data;
	int next;
}SLinkList[MaxSize];


void main() {
	LinkList L;
	InitList1(L);
}

需要数据结构、计算机网络、操作系统、计算机组成原理、c语言等等学习视频的！！！！！
微信公众号：小小小灵通 回复：王道 获取王道的教学视频、笔记、文档等提升课。（免费获取）

名称是：小小小灵通
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构相关算法
Atkx's Blog
10-24 1195
顺序表基本运算的实现 假设ElemType为char类型，使用自定义类型语句 typdef char ElemType; 数组大小一般定义为一个整型常量，例如，把MaxSize定义为50 #define MaxSize 50 定义结构体SqList typedef struct { ElemType data[MaxSize]; //存放顺序表元素 int length; //存放顺序表的长度 } SqList; //顺序表的类型定义 1.建立顺序表 void Creat
数据结构-线性表的链式表示--单链表的基本操作（初始化；销毁；头插法，尾插法创建；按序号，按值查找；求长度；插入；删除；合并；打印）（带注解）
qq_62630363的博客
11-19 338
为了避免顺序表在做插入，删除操作时，要移动大量元素，我们用链式存储结构来标识线性表，但它同时也失去了顺序表的可随机存取的优点。
线性表的使用（数据结构）
最新发布
qq_63865140的博客
04-20 144
定义一个线性表如下#define LIST_INIT_SIZE 100 //线性表的初始空间长度#define LISTINCREMENT 10 //线性表的增加空间长度//线性表定义：int length;//当前线性表长度//当前线性表分配的长度(以sizeof(ElemType)为单位)}SqList;
数据结构知识总结笔记------第二章：线性表 线性表的基本概念与实现、线性表的顺序表示、线性表的链式表示、顺序表和链表的比较
DKPT的博客
03-28 1569
第二章 线性表 2.1、线性表的基本概念与实现 2.1.1、线性表的定义 线性表是具有相同数据类型的n(n≥0)个数据元素的有序序列，其中n为表长，当n=0时该线性表就成为一个空表。 若用L来表示线性表，则可以表示为 L=（A1, A2，A3,…,An） 上面的表达式中A1是唯一的“第一个”数据元素，称为表头元素；An是唯一的“最后一个”数据元素，称为表尾元素。除了表头元素外，每一个元素都有且只有一个直接前驱，除了表尾元素外，每一个元素都有且只有一个直接后继。总的来说就是除了表头元素和表尾元素，剩余的元素都
静态分配线性表的顺序存储（Sequence List）
qq_41228018的博客
05-09 211
#include<cstdio> using namespace std; #define MaxSize 100 typedef struct { int data[MaxSize]; int length; } SeqList; //遗留问题：使用位序还是次序？这里使用的是位序 void InitList();//初始化线性表：构造一个空的线性表 int Length(SeqList &seqlist);//求表长：返回线性表中元素的个数 int Loca.
【C语言习题】用程序实现“线性表”数据的初始化、输入、输出、销毁、清空
qq_42910355的博客
03-25 3283
题目内容：用程序实现“线性表”数据的初始化、输入、输出、销毁、清空... #define _CRT_SECURE_NO_WARNINGS //防报错 #include<stdio.h> #include<stdlib.h> #define Maxsize 100 #define Succeed 1 #define Overflow -1 typedef int Status; typedef struct { int* elem; int length; }SqList;
2016年考研核心考点——数据结构1
08-03
接着，线性表是第二章的重点内容： 1. 线性表的定义与基本操作：线性表是最基础的数据结构之一，由n个相同类型元素构成的有限序列。它的基本操作包括插入、删除、查找等。线性表可以采用顺序存储或链式存储实现，每...
2009最新考研计算机专业大纲——数据结构
11-28
严蔚敏主编的《数据结构(第二版)》是大纲推荐的参考教材，特别指出应使用C语言版本。配合新版的《数据结构 1800 题》进行复习，可以帮助考生深入理解和练习数据结构的相关知识。 大纲未包含绪论章节的直接考察，但...
数据结构1800题
10-08
第2章“线性表”是数据结构的基础，包括数组和链表两种主要实现方式。线性表的操作如插入、删除、查找等在这里会有深入的练习。线性表的习题可能涉及动态数组、栈（后进先出LIFO）和队列（先进先出FIFO）等应用。 ...
2016年考研核心考点—数据结构1
08-03
第二章线性表主要讨论： 1. **线性表的定义和基本操作**：线性表是最简单也是最基础的逻辑结构，由n个相同类型元素构成的有限序列。其基本操作包括插入、删除、查找、排序等。线性表的存储结构通常有顺序表和链表两...
线性表【数据结构学习-青岛大学王卓老师】
给我一碗炒粉的博客
08-14 128
青岛大学王卓老师数据结构学习
【数据结构】第二章 线性表的基本知识及代码实现（1）
weixin_64682807的博客
03-19 2224
一、线性表的定义和特点 1、定义：由n(n>=0)个数据元素（结点）组成的有序序列 2、逻辑特征：同一线性表中的元素必须具有相同的特性，数据元素之间的关系为线性。线性表是一种典型的线性结构。 二、线性表的基本定义 1、抽象数据类型的线性表定义如下： ADT List{ 数据对象：D={ai | ai属于Elemset，(i=1,2,....n)} 数据关系：R={<ai-1,ai>,ai-1和ai属于D} 数据操作：InitList（&L）等 }ADT List
顺序线性表基本操作（初始化，插入，删除，销毁，清空等等）+简单小例题
qq_42319367的博客
11-08 7499
转专业后，感觉这个数据结构是最吃老本的。。。 写点简单的代码，求各位大神放过，都是小萌新的艰辛泪啊 感觉比较适合像我这样基础差的小萌新 #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define ElemType int #define OK 1 #define ERROR 0 #define Status int #define ...
线性表
weixin_30466421的博客
03-19 166
一、线性结构的特点 线性表是n个数据元素的有限序列，具有如下几个特点： 　　1）存在唯一的第一个元素； 　　2）存在唯一的最后一个元素； 　　3）除了第一个和最后一个元素外，其余的都只有一个前驱和一个后继 　 一个数据元素可以由多个数据项组成： 二、抽象数据类型线性表的定义 ADT List { 　　　　数据对象：D = {ai | ai ∈ Elem...
数据结构—顺序表的销毁
qq_39830449的博客
08-20 1万+
//顺序表的销毁 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define OK 1 #define OVERFLOW -2 #define LIST_INIT_SIZE 10// 线性表存储空间的初始分配量 typedef int Status; //Status是函数数据类型 ，其值是函数结果状态，如OK typedef ...
1-2、数据结构线性表之顺序表的基本操作插入、删除、遍历、初始化
热门推荐
xiaok_dev
04-16 1万+
学习需要记录，更需要温习！ 上一篇我们总结了什么是线性表，线性表的ADT类型，线性表的两种存储类型顺序存储结构和链式存储结构，今天正式进入线性表的顺序存储结构的总结和归纳，也就是数据结构的线性表的顺序表的讲解。 1、什么是顺序表？ 顺序表就是用一组连续的存储单元依次...
算法与数据结构--实现线性表的删除操作--算法2.4
leihengxin的专栏
09-16 5883
/* (程序头部注释开始) * 程序的版权和版本声明部分 * Copyright (c) 2011, 烟台大学计算机学院学生 * All rights reserved. * 文件名称：实现线性表的插入和删除操作 * 作 者： 雷恒鑫 * 完成日期： 2012 年 09 月 16 日 * 版 本 号： V1.0 * 对任务及求解方法的描述部分 * 输入描述： * 问题描述：
算法与数据结构课件PPT第二章
07-16
"第二章线性表的详细讲解，包括线性表的概念、抽象数据类型、顺序表和链表的实现以及操作" 线性表是一种基础且重要的数据结构，它由n（n≥0）个相同性质的元素组成，这些元素以特定的顺序排列形成一个有序序列。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

名称是：小小小灵通

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值