笔记:一般线性表

已于 2022-04-15 13:49:00 修改
阅读量677 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
于 2022-01-06 10:39:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Polaris17877/article/details/122337674
版权

一、顺序表

顺序存储,通过静态或动态开辟[数组]存储数据,可分为静态顺序表和动态顺序表
在这里插入图片描述

静态顺序表 SqList

1. 类型定义

#define MaxSize 10
typedef struct 
{
	ElemType data[MaxSize];  //静态数组 存放元素类型为ElemType,使用完自动回收
	int length;              //当前静态数组中元素个数,即表长
}SqList;

2. 初始化

bool InitList(SqList &L)    
{
	int i = 0;
	for(i = 0; i<MaxSize; i++)     //数组元素设置为0
		L.data[i] = 0;
	L.length = 0;				   //表长设置为0
    return true;
}

3. 判空

bool Empty(SqList L)
{
    return (L.length == 0);
}

4. 插入元素

bool ListInsert(SqList &L, int i, ElemType e)  //插入到表的第i位,即data[i-1]
{
	if(i<1|| i>L.length+1|| L.length==MaxSize) //非法输入或表满
		return false;
	int j = 0;
	for(j = L.length; j>=i; j--)
		L.data[j] = L.data[j-1]; //从后至前, 将data[i-1]及之后元素后移
	L.data[i-1] = e;             //插入
	L.length++;                  //表长+1
    return true;
}

5. 删除元素

bool ListDelete(SqList &L, int i, ElemType &e) //找到表的第i位,即data[i-1],返回至e并从表中删除
{
	if(i<1|| i>L.length)                     //非法输入
		return false;
	e = L.data[i-1];					     //导出data[i-1]至e
	int j = 0;
	for(j = i; j<=L.length - 1; j++)         //从前至后,将data[i]及之后元素前移
		L.data[j-1] = L.data[j]
	L.length--;                              //表长-1
    return true;
}

6. 定位元素位序

int LocateElem(SqList L,ElemType e)
{
	int i = 0;
	for(i = 0; i<L.length ;i++)
		if(L.data[i] == e)  
			return i + 1;   //找到data[i],位置为第i+1个元素
	return 0;	            //查找失败
}

注:顺序表的LocateElem返回的是第一次出现元素e的位序,链表的LocateElem返回的是第一次出现元素e的结点的指针

7. 获取位序元素

ElemType GetElem(SqList L,int i)
{
	assert(i<1|| i>L.length)  ;                   //非法输入
	return L.data[i-1];
}

注:顺序表的GetElem返回的是位序i的元素值,链表的GetElem返回的是第i结点的指针

动态顺序表 SeqList

1. 类型定义

#define InitSize 10  //第一次动态开辟的Elemtype数量
typedef struct  
{
	ElemType* data;			//动态数组 存放元素类型为ElemType
	int length;             //当前动态数组中元素个数,即表长
	int MaxSize;            //当前动态数组中元素的最多个数,即最大表长
}SeqList;

2. 初始化

bool InitList(SeqList &L)
{
	L.data = (ElemType*)malloc(InitSize*sizeof(Elemtype))  //在L.data动态开辟InitSize个Elemtype的大小
	if(L.data == NULL)
		return false;
	L.length = 0;                //表长设置为0
	L.MaxSize = InitSize;        //最大表长设置为InitSize
    return true;
}

3. 扩大空间

bool IncreaseSize(SeqList &L, int len) //扩充len个空间
{
	ElemType* p = (ElemType*)realloc(L.data, (L.MaxSize + len)*sizeof(ElemType)); 
 //在临时指针p动态开辟(当前最大表长+len)个Elemtype的大小,并将L.data数据导入
	if(p == NULL)
		return false;
	L.data = p;            //p的地址给L.data
	L.MaxSize += len;      //最大表长扩大len
    return true;
}

4. 插入元素

bool ListInsert(SeqList &L, int i, ElemType e)  //插入到表的第i位,即data[i-1]
{
	if(i<1|| i>L.length+1|| L.length==L.MaxSize) //非法输入或表满
		return false;
	int j = 0;
	for(j = L.length, j>=i, j--)
		L.data[j] = L.data[j-1]; //从后至前, 将data[i-1]及之后元素后移
	L.data[i-1] = e;             //插入
	L.length++;                  //表长+1
    return true;
}

二、链表

建立结点,每个结点除了存放数据之外,还存放指向其他结点的指针.

单链表 LinkList

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

1. 类型定义

typedef struct LNode
{
	ElemType data;   //数据域
	struct LNode* next;  //指针域,指向下一个节点
}LNode,*LinkList; //LinkList用来强调单链表,LNode强调结点

LinkList L; L为未被赋值的LNode型的指针,类似于初始化函数,L指针保存的地址初始化为指向开辟的LNode空间的地址,即指针本身发生了变化,所以要&,类似于修改链表节点值的函数,只修改了L指向的LNode里的data和next值,不改变L本身,所以不用&.

2. 初始化

//不带头结点
bool InitList(LinkList &L)
{
	L = NULL;    //防止脏数据
	return true;
}
//带头结点
bool InitList(LinkList &L) 
{
	L = (LNode*)malloc(sizeof(LNode));
	if(L == NULL)
		return false;
	L->next = NULL;
	return true;
}

3. 判空

//不带头结点
bool Empty(LinkList L)
{
	return (L == NULL);
}
//带头结点
bool Empty(LinkList L)
{
	return (L->next == NULL);
}

4. 求表长

//无头结点
int Length(LinkList L)
{
	if(Empty(L))
		return 0;         //空表为0
	int length = 1;
	Node* p = L;          //从第一个结点出发
	while(p->next != NULL)
	{
		p = p->next;
		length++;
	}
	return length;
}
//有头结点
int Length(LinkList L)
{
	if(Empty(L))
		return 0;
	int length = 1;
	Node* p = L->next;
	while(p->next != NULL)
	{
		p = p->next;
		length++;
	}
	return length;
}

5. 给定元素获取指针

//不带头结点
LNode* LocateElem(LinkList L,ElemType e)
{
	LNode* p = L;  //从第一个结点开始找
	while(p!= NULL && p->data!=e)  //直到找到e元素
		p = p->next;
	return p;   //找到后返回该结点指针 找不到返回NULL
}
//带头结点
LNode* LocateElem(LinkList L,ElemType e)
{
	LNode* p = L->next;  
	while(p!= NULL && p->data!=e)  
		p = p->next;
	return p;   
}

注:都要从第一个存储数值的结点开始匹配e的值

6. 给定位序获取指针

//不带头结点
LNode* GetElem(LinkList L,int i)
{
	if(i<1)
		return NULL;   //非法输入
	LNode* p = L;      //从第一个结点开始
	int j = 1;
	while(p != NULL && j<i) 
	{
		p = p->next;
		j++;
	}
	return p ; //返回i结点指针,若i大于表长则返回NULL
}
//带头结点
LNode* GetElem(LinkList L,int i)
{
    if(i == 0)
        return L;      //返回头结点
	if(i<1)
		return NULL;   //非法输入
	LNode* p = L->next;      //从第一个结点开始
	int j = 1;
	while(p != NULL && j<i) 
	{
		p = p->next;
		j++;
	}
	return p ; //返回i结点指针,若i大于表长则返回NULL
}

7. 指定结点后插

bool InsertNextNode(LNode* p,ElemType e)
{
	if(p == NULL)
	    return false;  
	LNode* s=(LNode*)malloc(sizeof(LNode)); //s指向新插入的结点
	if(s == NULL)
		return false;  //内存分配失败
	s->data = e;       //新结点赋值
	s->next = p->next; //新结点指向原p之后的结点
	p->next = s;       //p指向新结点 
	return true;
}

8. 指定结点前插

原理:指定结点后插之后,交换两结点的data数据

bool InsertPriorNode(LNode* p,ElemType e)
{
	if(InsertNextNode(p,e))
	{
		ElemType temp = p->data;
		p->data = p->next->data;
		p->next->data = temp;
		return true;
	}
	else 
		return false;
}

9. 指定位序插入

原理:利用GetElem找到i-1结点的指针,对i-1结点进行后插操作

//不带头结点
bool ListInsert(LinkList &L, int i ,ElemType e)
{
	if(i<1)
		return false;   //非法输入,i过小
	if(i == 1)          //第一个结点
	{
		LNode* s=(LNode*)malloc(sizeof(LNode));//s指向新插入的结点
		s->data = e;       //新结点赋值
		s->next = L;	   //新结点的next指针指向原来的首结点
		L = s;             //改变指向第一个结点的指针L
	}
	LNode* p = GetElem(L,i-1); //p指向i-1结点
	return InsertNextNode(p,e)
 //如果return false,可能由于非法输入,i大于表长+1导致GetElem返回NULL 或者内存开辟失败
}
//带头结点
bool ListInsert(LinkList &L, int i ,ElemType e)
{
	if(i<1)
		return false;   //非法输入,i过小
	LNode* p = GetElem(L,i-1); //p指向i-1结点
	return InsertNextNode(p,e)
}

注:无头结点需要对i=1进行特殊处理,因此大多数情况都建立带头结点链表

10. 指定结点删除

原理:将后续结点的数据域和指针域转移给其本身,然后释放后续结点

bool DeleteNode(LNode* p, ElemType &e)
{
	if(p == NULL || p->next == NULL) 
//p指向尾结点时方法不可用,需遍历至next指向p的结点,另其next指针指向NULL,并释放原后续结点p
		return false;
    e = p->data;
	LNode* q = p->next;  //q指向p后续结点
	p->data = q->data;        //转移数据域
	p->next = q->next;        //转移指针域
	free(q);
	return true;
}

11. 指定位序删除

原理:利用GetElem找到i-1结点的指针,进行后续操作

//不带头结点
bool ListDelete(LinkList &L, int i, Elemtype &e)
{
	if(i == 1)
	{
		Node* p = L;
		e = p->data;
		L = L->next;
		free(p);
	}
	Node* p = GetElem(L,i-1); //p指向i-1结点
	if(p == NULL || p->next == NULL)//i-1 结点为空或i-1结点无后续结点
		return false; 
	LNode* q = p->next; //q指向i结点,即待删除结点
	e = q->data;
	p->next = q->next;
	free(q);
	return true;
}
//带头结点
bool ListDelete(LinkList &L, int i, Elemtype &e)
{
	Node* p = GetElem(L,i-1);
	if(p == NULL || p->next == NULL)
		return false; 
	LNode* q = p->next; 
	e = q->data;
	p->next = q->next;
	free(q);
	return true;
}

12. 头插法建立单链表

对传入的已被初始化的链表头指针L进行逆向建表

LinkList List_HeadInsert(LinkList &L)
{
	Elemtype x;
	LNode* s;
	scanf("",&x);
	while(x!=9999)
	{
		s = (LNode*)malloc(sizeof(Node));
		s->data = x;
		s->next = L->next; 
		L->next = s;
		scanf("",&x);
	}
	return L;
}

13 .尾插法建立单链表

对传入的已被初始化的链表头指针L进行正向建表

LinkList List_TailInsert(LinkList &L)
{
	ElemType x;
	LNode* r = L;//尾指针
	LNode* s ;   //s指向新结点
	scanf("",&x);
	while(x!=9999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;  
		s->next = NULL;
		r->next = s;  //当前尾结点指向新结点
		r = s;        //尾指针指向新结点
		scanf("",&x);
	}
	return L;
}

双链表 DLinkList

在这里插入图片描述

1.类型声明

typedef struct DNode
{
	ElemType data;
	struct DNode* prior;
	struct DNode* next;
}DNode,*DLinkList;

2.初始化

bool InitList(DLinkList &L)
{
	L = (DNode*)malloc(sizeof(DNode));
	if(L == NULL)
		return false;
    L->prior = NULL;
	L->next = NULL;
	return true;
}

3.指定结点后插

在这里插入图片描述

bool InsertNextNode(DNode* p,ElemType e)
{
	if(p == NULL)
	    return false;   
	DNode* s=(DNode*)malloc(sizeof(DNode)); //s指向新插入的结点
	if(s == NULL)
		return false; 
	s->data = e;       
	s->next = p->next; 
	if(p->next != NULL)   // p如果没有后续结点
		p->next->prior = s;       //p的下一个结点的前指针指向新结点 
	s->prior = p;
	p->next = s;
	return true;
}

4.指定结点删除

bool DeleteNode(DNode* p, ElemType &e)
{
	if(p == NULL || p->next == NULL) 
		return false;
    e = p->data;
	p->prior->next = p->next;
    p->next->prior = p->prior;
	free(p);
	return true;
}

循环链表 CLinkList

1.单循环链表

在这里插入图片描述
类型定义与单链表相同

初始化时需要 L->next = L;

判空条件 L->next == L

2.双循环链表

在这里插入图片描述
类型定义与双链表相同

初始化时需要 L->prior = L; L->next = L;

判空条件 L->next == L

静态链表 SLinkList

在这里插入图片描述

1. 类型定义

#define MaxSize 10
typedef struct
{
    ElemType data;
    int next;
}SlinkList[MaxSize];

​

asdvbdgerb
关注
专栏目录
Java算法笔记05：线性表-顺序表
那人独钓寒江雪
07-28 357
代码】Java算法比较05线性表-顺序表。
数据结构总结笔记1：线性表总结
Joye-joy的博客
05-28 1561
最近进行数据结构的复习，并将重点的一些线性表的知识点用图的方式进行总结，以方便进行复习、查看。 在此做一个总结记录。后续会更新上算法程序部分。 1，线性表的知识结构图 1.1线性表定义 线性表是一个具有相同特性的数据元素的有限序列。 相同特性：所有元素属于同一数据类型。 有限：数据元素个数是有限的。 序列：数据元素由逻辑序号唯一确定。一个线性表中可以有相同值的元素。 1....
一般线性表
qq_43715670的博客
08-31 459
基础概念和术语 线性表是具有相同特性的数据的有限序列。如a1,a2,a3,an。其中n为表长，a1称为表头，an为表尾。表中元素除了表头和表尾均有且只有一个前驱和后继。 逻辑结构：线性有序 顺序表 采用顺序存储实现的线性表称为顺序表。使用物理结构的相邻来表明逻辑相邻。 创建时需指定最大数量Maxsize。 如： 1 2 3 4 5 6 7 其特点是能够实现随机访问(O(1))，存储密度大。 其在C...
数据结构与算法（2）— 一般线性表
04-05 2095
数据结构与算法（2）— 一般线性表(mi6236)1、线性表定义具有相同数据类型元素的一个有限序列。其基本特征为在一个非空线性结构中，有且只有一个称为第一个的元素；有且只有一个称为最后一个的元素。第一个元素无前驱，最后一个元素无后继，其余每个元素均有唯一前驱和唯一后继。    线性表是一种线性结构，任何一种线性结构都可以用线性表的形式表示。2、线性表的顺序存储结构    线
数据结构第四篇——（一般）线性表（基于C语言）
qq_34028001的博客
08-02 388
前言 以下描述内容以C语言为主，Java只是作为实现的补充。 一、线性表的定义及性质 线性表是由n(n>=O)个数据类型相同的元素构成的有限序列。 线性表中元素的个数n(n>=O)定义为表长，n=O时称为空表。 线性表按照存储结构的不同，又划分为顺序表和链式表。 1.1 顺序表的定义及其特点 顺序表（Sequential List）：用一组地址连续的存储单元依次存储线性表的数据元素。 其特点是： 逻辑上相邻的数据元素，其物理次序也是相邻的； 随机访问，可以在O(1)时...
我的数据结构与算法「一般线性表」
昊大侠的博客
04-01 891
文章目录线性表线性表的主要操作顺序表顺序表的实例顺序表的插入顺序表的删除链表单链表头插法建立单链表尾插法建立单链表按序号查找结点按值查找结点插入操作删除操作求表长操作双链表插入操作删除操作循环链表与静态链表 线性表 线性表通常指一般线性表，是线性逻辑结构且具有相同数据类型的 nnn 个数据元素的有限序列。其中 nnn 为表长。当 n=0n=0n=0 时 线性表是一个空表；线性表中第一个数据元素称为表头数据元素有且只有一个直接后继，最后一个数据元素称为表尾数据元素有且只有一个直接前驱，其他数据元素有且仅有一个
顺序表与链表
didiao7566的专栏
09-11 303
顺序表与链表是非常基本的数据结构，它们可以被统称为线性表。 线性表（Linear List）是由 n（n≥0）个数据元素（结点）a[0]，a[1]，a[2]…，a[n-1] 组成的有限序列。 顺序表和链表，是线性表的不同存储结构。它们各自有不同的特点和适用范围。针对它们各自的缺点，也有很多改进的措施。 一、顺序表 顺序表一般表现为数组，使用一组地址连续的存储单元依次存储数据元素，...
1324: 算法2-2：有序线性表的有序合并
一零之间
07-24 2979
1324: 算法2-2：有序线性表的有序合并 时间限制: 1 Sec内存限制: 32 MB提交: 1582解决: 335 题目描述 已知线性表 LA 和 LB 中的数据元素按值非递减有序排列，现要求将 LA 和 LB 归并为一个新的线性表 LC， 且 LC 中的数据元素仍然按值非递减有序排列。例如，设LA=(3,5,8,11) ,LB=(2,6,8,9,11,15,20) 则 LC=(2,
数据结构——栈和队列
《@书山有径%》的博客
02-23 209
栈和队列 栈 定义栈 #define MaxSize 10 //定义栈中元素的最大个数 typedef struct { int data[MaxSize];//静态数组存放栈中元素 int top;//栈顶指针 } SqStack; void testStack() { SqStack S;//声明一个顺序栈（分配空间） } 初始化栈 //初始化栈 void InitStack(SqStack *S) { S->top=-1;//初始化栈顶指针 } 判断栈空
顺序队列
qq_32113889的博客
07-20 498
#include <stdio.h> #include <stdbool.h> #include <stdlib.h> #define MaxSize 10 typedef struct { char name[20]; }ElemType; typedef struct { ElemType data[MaxSize]; int front,rear; // int size; 这种方法可以不浪费那个多出来的空间，不过却多了一.
数据结构个人笔记
最新发布
KeyISee的博客
12-18 284
数据结构 理解 快速复习
数据结构——栈（Stack）（小白入门第三天）
qq_50645064的博客
07-17 1398
小白自学进阶道路
顺序表的相关操作--静态动态分配实现初始化、插入、删除、查找、判空、求表长
qq_51514930的博客
05-14 1337
一、顺序表的实现： 静态分配顺序表的定义： #define MaxSize 10 //定义最大长度 typedef struct{ ElemType data[MaxSize]; //用静态的数组存放元素 int length; //顺序表的当前长度 }Sqlist;
线性表：顺序表实现
ysg.name
09-03 524
在此记录，方便以后学习回顾 #include #include using namespace std; #define MaxSize 100 typedef int ElemType; typedef struct{ ElemType data[MaxSize]; int length; }SqList; /* #define InitSize 100 typedef struct{
【数据结构复习03】队列的顺序存储实现及基本操作
weixin_43951940的博客
06-09 1251
队列的顺序存储实现及基本操作 队列的顺序存储类型描述 #define MAXSIZE 10 typedef struct{ int data[MAXSIZE]; //存放队列元素 int front,rear; //队头指针和队尾指针 }SqQueue; 注意事项 顺序队列的队尾指针有两种情况，一种是将队尾指针指向队尾元素，一种是将队尾指针指向队尾元素的后一位(本文采取这种情况)，两种情况在初始化时，前者为：front=0,rear=-1;后者为：front=rear=0。除此外，两种情况在判空
数据结构 【顺序表】 部分功能实现
m0_62685465的博客
03-10 710
1.顺序表的实现--静态分配 #define MaxSize 10 //定义最大长度 typedef struct { ElemType data[MaxSize]; //静态数组存放元素 int length; //顺序表当前长度 }SqList; 2.初始化一个顺序表 #define MaxSize 10 //定义最大长度 typedef struct { int data[MaxSize]; int length; }SqList; //基本操作，初始化一个顺序表 void Init
C语言学习历程（十七）数据结构与排序（冒泡、选择、希尔排序）算法
Zhanganliu的博客
01-16 493
include define MAXSIZE 10typedef struct SqList { int data[MAXSIZE+1]; /设置一个哨兵data【0】/ int length; }SqList;int swap(SqList L,int i,int j) /交换函数*/ { int t = L -> data[
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值