数据结构线性表常用操作及代码总结

已于 2024-07-03 11:37:50 修改
阅读量718 收藏 28
点赞数 26
分类专栏： 数据结构笔记 文章标签： 数据结构 考研
于 2024-07-03 11:34:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1669820631/article/details/126693434
版权

数据结构

  • 线性表
    • 顺序表
      • 静态分配定义顺序表
      • 动态分配定义顺序表
      • 顺序表元素插入
      • 顺序表元素的删除
      • 按位查找元素
      • 按值查找元素
    • 单链表
      • 单链表结构体定义及初始化
      • 单链表是否为空
      • 单链表_按位插入_不带头结点
      • 单链表_按位插入_带头结点
      • 单链表_指定节点后插
      • 单链表_指定节点前插
      • 单链表_按位删除_带头结点
      • 单链表_删除指定节点
      • 求表长
      • 单链表_按位查找
      • 单链表_按值查找
      • 单链表_建立_尾插法
      • 单链表_建立_头插法
    • 双链表
      • 逻辑结构定义
      • 双链表_初始化
      • 双链表_判断是否为空
      • 双链表_插入_后插
      • 双链表_插入_前插
      • 双链表_删除
      • 双链表_销毁
      • 双链表_遍历
    • 循环链表
      • 循环单链表_逻辑结构定义
      • 循环单链表_初始化
      • 循环单链表_判断是否为空
      • 循环单链表_判断节点p是否为表尾节点
      • 循环双链表_逻辑结构定义
      • 循环双链表_初始化
      • 循环双链表_判断是否为空
      • 循环双链表_判断节点p是否为表尾节点
    • 静态链表
      • 静态链表_逻辑结构定义

线性表

顺序表

静态分配定义顺序表

#include <stdio.h>
#define MaxSize 10
//定义静态结构体
typedef struct{
	ElemType data[MaxSize];
	int length;
}SqList;
//初始化
void InitList(SqList &L){
	for(int i = 0;i < MaxSize;i++){
		L.data[i] = 0;
		L.length = 0;
	}
}
//使用
int main(){
	SqList L;
	InitList(L);
	return 0;
}

动态分配定义顺序表

#include <stdio.h>
//定义动态结构体
#define InitSize 10
typedef struct{
	int *data;
	int MaxSize;
	int length;
}SeqList;
//初始化
void InitList(SeqList &L) {
	L.data = (ElemType*)malloc(sizeof(ElemType)*InitSize;
	L.length = 0;
	L.MaxSize = InitSize;
}
//增加数组长度
void IncreaseSize(SeqList &L, int len){
	int *p = L.data;
	L.data = (int*)malloc(sizeof(ElemType)*(L.MaxSize+len));
	for(int i = 0;i < L.length;i++){
		L.data[i] = p[i];
	}
	L.MaxSize += len;
	free(p);
}
//使用
int main(){
	SeqList L;
	InitList(L);
	IncreaseSize(L,5);
	return 0;
}

顺序表元素插入

ListInsert(&L,i,e) - 在第i个位置上插入指定元素e
插入的时间复杂度：最好O(1)，最坏O(n)

void ListInsert(SqList &L,int i,int e){
	for(int j = L.length;j > i;j--){
		L.data[j] = L.data[j-1];
	}
	L.data[i-1] = e;
	L.length++;
}
//为了避免插入元素没有反馈，进一步更新
bool ListInsert(SqList &L,int i,int e){
	if(i < 1 || i > L.length)   //i取值无效，超出范围
		return false;
	if(L.length >= MaxSize)  //满了
		return false;
	for(int j = L.length;j > i;j--){
		L.data[j] = L.data[j-1];
	}
	L.data[i-1] = e;
	L.length++;
	return true;
}

顺序表元素的删除

ListDelete(SqList &L,int i,ElemType &e) - 删除第i个元素并返回该元素
删除的时间复杂度：最好O(1)，最坏O(n)，平均O(n)

bool ListDelete(SqList &L,int i,ElemType &e){
	if(i < 1 || i > L.length)
		return false;
	e = L.data[i-1];
	for(int j = i; j < L.length;j++){
		L.data[j-1] = L.data[j];
	}
	L.length--;
	return ture;
}
//使用
int main(){
	SqList L;
	InitList(L);
	int e = -1;			//注意
	if(ListDelete(L,3,e))
		printf("删除成功，元素为%d/n",e);
	else
		printf("删除失败"/n);
	return 0;
}

按位查找元素

GetElem(L,i) - 获取表L中的第i个位置的元素的值
按位查找的时间复杂度：O(1)

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

按值查找元素

LocateElem(SqList L,ElemType e) - 在表中查找给定元素的位置
删除的时间复杂度：最好O(1)，最坏O(n)，平均O(n)

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

单链表

单链表结构体定义及初始化

typedef struct LNode{
	ElemType data;
	struct LNode *next;
}LNode,*LinkList; //typedef struct LNode;
				  //typedef struct *LinkList;
bool InitList(LinkList &L){
	L = NULL;
	return true;
}
//初始化单链表——不带头结点
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;
}
//使用
int main(){
	LNode *L;  //同样
	LinkList L;
	InitList(L);
}

单链表是否为空

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

单链表_按位插入_不带头结点

时间复杂度为O(n)

bool ListInsert(LinkList &L,int i,ElemType e){
	if(i < 1)
		return fasle;
	if(i == 1){		//第一个节点插入与其他不同
		LNode *s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		s->next = L;
		L = s;
	}
	LNode *p;
	int j = 1;
	p = L;		//p指针指向L的第一个元素
	while(p != NULL && j < i-1){  //使p指向i位置的前一个元素
		p = p->next;
		j++;
	}
	if(p == NULL)		//i不合法
		return false;
	//此时p指向要插入元素的前一个元素
	LNode *s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

单链表_按位插入_带头结点

时间复杂度为O(n)

bool ListInsert(LinkList &L,int i,ElemType e){
	if(i < 1)
		return false;
	LNode *p;
	int j = 0;
	p = L;
	while(p != NULL && j < i-1){
		p = p->next;
		j++;
	}
	if(p == NULL){	//i不合法		
		return false;
	}		
	//此时p指向要插入元素的前一个元素
	LNode*s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

单链表_指定节点后插

InsertNextNode(LinkList &L,int i,ElemType e):在p节点之后插入元素e
主要的时间开销在于查找第i-1个元素，时间复杂度为O(n)

//后插操作
InsertNextNode(LNode *p,ElemType e){
		if(p == NULL){	//i不合法
		return false;
	}
	//此时p指向要插入元素的前一个元素
	LNode *s = (LNode*)malloc(sizeof(LNode));
	if(s == NULL)	//内存分配失败
		return false;
	s->data = e;
	s->next = p->next;		
	p->next = s;
	return true;
}
//使用
bool ListInsert(LinkList &L,int i,ElemType e){
	if(i < 1)
		return false;
	LNode *p;
	int j = 0;
	p = L;
	while(p != NULL && j < i-1){
		p = p->next;
		j++;
	}
	return InsertNextNode(p,e);
}

单链表_指定节点前插

InsertPriorNode(LNode *p,ElemType e):在p节点之前插入元素e
正常后插操作，然后交换数据
时间复杂度为O(n)

bool InsertPriorNode(LNode *p,ElemType e){
	if(p == NULL)
		return false;
	//此时p指向要插入元素的前一个元素
	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;
}

单链表_按位删除_带头结点

ListDelete(LinkList &L,int i,ElemType &e):删除第i个位置的元素并带回
算法主要时间开销耗费在查找上，时间复杂度为O(n)

bool ListDelete(LinkList &L,int i,ElemType &e){
	if(i < 1)
		return false;
	LNode *p;
	int j = 0;
	p = L;
	while(p != NULL && j < i-1){
		p = p->next;
		j++;
	}
	if(p == NULL)
		return false;
	if(p->next == NULL)
		return false;
	LNode *q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);
	return true;
}

单链表_删除指定节点

DeleteNode(LNode *p):删除某个给定节点p
p指向要删除的元素
时间复杂度为O(1)

bool DeleteNode(LNode *p){
	if(p == NULL)
		return false;
	LNode *q = p->next;
	p->data = q->data;		//将p指向元素的下一个元素的数据往前移
	p->next = q->next;		//将p指向的元素的下下个元素地址给p
	free(q);				//然后释放q
	return true;
}

求表长

Length(LinkList L):求表长

int Length(LinkList L){	//带头结点
	if(L->next == NULL){
		return 0;
	}
	LNode *p = L->next;
	int len = 1;
	while(p != NULL){
		p = p->next;
		len++;
	}
	return len;
}
int Length(LinkList L){	//不带头结点
	if(L == NULL){
		return 0;
	}
	LNode *p = L;
	int len = 1;
	while(p != NULL){
		p = p->next;
		len++;
	}
	return len;
}

单链表_按位查找

GetElem(LinkList L,int i):按序号查找元素
时间复杂度为O(n)

LNode *GetElem(LinkList L,int i){
	if(i == 0){
		return L;
	}
	if(i < 0)
		return NULL;
	LNode *p = L->next;
	int j = 1;
	while(p != NULL && j < i){
		p = p->next;
		j++;
	}
	return p
}

单链表_按值查找

LocateElem(LinkList L,ElemType e):给定值e,查找元素
时间复杂度为O(n)

LNode *LocateElem(LinkList L,ElemType e){
	LNode *p = L->next;			//默认带头结点
	while(p != NULL && p->data != e)
		p = p->next;
	return p;
}

单链表_建立_尾插法

List_TailInsert(LinkList &L):初始化一个单链表，并依次读取值添加至表尾
设单链表的长度为n，则时间复杂度为O(n)

LinkList List_TailInsert(LinkList &L){
	ElemType e;
	L = (LinkList)malloc(sizeof(LNode));	//建立头节点
	LNode *s,*r = L;  //r表尾指针，s新结点指针
	scanf("%d",&e);
	while(e != 9999){	//9999代表结束
		s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		r->next = s;
		r = s;		//使r指向表尾
		scanf("%d",&e);
	}
	r->next = NULL;
	return L;
}

单链表_建立_头插法

List_TailInsert(LinkList &L):初始化一个单链表，并依次读取值添加至表头
时间复杂度为O(n)

LinkList List_TailInsert(LinkList &L){
	ElemType e;
	LNode *s;
	L = (LinkList)malloc(sizeof(LNode));	//建立头节点
	L->next = NULL;
	scanf("%d",&e);
	while(e != 9999){	//9999代表结束
		s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		s->next = L->next;
		L->next = s;
		scanf("%d",&e);
	}
	return L;
}

双链表

逻辑结构定义

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

双链表_初始化

InitDLinkList(DLinkList &L)：初始化

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

双链表_判断是否为空

Empty(DLinkList L):判断是否为空

bool Empty(DLinkList L){
	return (L->next == NULL);
}

双链表_插入_后插

InsertNextDNode(DNode p,DNode s):在双链表p所指节点后面插入结点s

bool InsertNextDNode(DNode *p,DNode *s){
	s->next = p->next;
	p->next->prior = s;
	p->next = s;
	s->prior = p;
	return true;
}

双链表_插入_前插

InsertNextDNode(DNode *p,DNode s):在双链表p所指节点前插入节点s

bool InsertNextDNode(DNode *p,DNode *s){
	s->prior = p->prior;
	p->prior->next = s;
	s->next = p;
	p->prior = s
	return true;
}

双链表_删除

bool DeleteDNode(DNode *p):删除p节点的后继节点q

bool DeleteDNode(DNode *p){
	if(p == NULL)
		return false;
	DNode *q = p->next;		//找到p的下一个节点
	if(q == NULL)
		return false;
	q->next->prior = p;
	p->next = q->next;
	free(q);
	return true;
}

双链表_销毁

void DestoryList(DLinkList &L):销毁链表

void DestoryList(DLinkList &L){
	while(L->next == NULL)
		DeleteDNode(DNode *p);	//从头开始删除
	free(L);		//剩下头节点--释放
	L = NULL;	!!!?
}

双链表_遍历

while(p != NULL)         //向后遍历
    p = p->next;
while(p != NULL)         //向前遍历
    p = p->prior;
//while(p->prior != NULL)  //向前遍历（跳过头结点）
//    p = p->prior;		!!!?

循环链表

循环单链表_逻辑结构定义

typedef struct LNode{
	ElemType data;
	struct LNode *next;
}LNode,*LinkList;

循环单链表_初始化

bool InitList(LinkList &L){
	L = (LNode*)malloc(sizeof(LNode));
	if(L == NULL)	//内存不足
		return false;
	L->next = L；
	return true;
}

循环单链表_判断是否为空

bool Empty(LinkList L){
	return L->next == L;
}

循环单链表_判断节点p是否为表尾节点

bool Empty(LinkList L,LNode *p){
	return p->next == L;
}

循环双链表_逻辑结构定义

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

循环双链表_初始化

bool InitDLinkList(DLinkList &L){
	L = (DNode*)malloc(sizeof(DNode));
	if(L == NULL)	//内存不足
		return false;
	L->next = L;
	L->prior = L;
	return true;
}

循环双链表_判断是否为空

bool Empty(DLinkList L){
	return L->next == L;
}

循环双链表_判断节点p是否为表尾节点

bool Empty(DLinkList L,DNode *p){
	return p->next == L;
}

静态链表

静态链表_逻辑结构定义

define MaxSize 10
typedef struct{
	ElemType data;
	int next;
}SLinkList[MaxSize]
int main(){
	SLinkList s;
}
Java程序员十六
关注
  • 26
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构-线性表的基本操作
qq_47911588的博客
06-29 2729
本文介绍我在学习数据结构的过程中如何利用线性表编写算法解决实际问题的方法线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。......
数据结构实验代码线性表的基本操作.rar
05-01
在这个“数据结构实验代码线性表的基本操作.rar”压缩包中，包含的应该是实现线性表各种基本操作的源代码，这些操作对于理解和掌握数据结构至关重要。 首先，我们需要理解线性表的主要操作： 1. 初始化：创建一个...
数据结构线性表基本操作
热门推荐
lizhi20210729的博客
11-20 1万+
数据结构线性表基本操作基本内容线性表的顺序表示和实现线性表的顺序存储表示顺序表中基本操作的实现 基本内容 因为第一次数据结构阶段考写代码又想规范写又写不出规范的可读性强的代码，让我第一次意识到自己应该在这方面下一些功夫。这篇文章是记录自己把书上写的算法打到电脑上遇到的问题。 线性表的顺序表示和实现 线性表的顺序存储表示 将书中代码复刻如下： #define MAXSIZE 100//顺序表可能达到的最大长度 typedef struct { ElemType *elem;//储存空间的基地址
C语言数据结构--线性表常用操作代码合集
m0_70744482的博客
04-03 563
数据结构线性表常用代码
数据结构——线性表（详细配代码讲解）
often_的博客
12-01 1259
在数据结构中，线性表是一种非常直观和容易理解的数据结构，它的操作也比较简单和直观。然而，在实际应用中，我们需要根据具体的问题和应用场景来选择合适的线性表实现方式，比如顺序存储结构或者链式存储结构等。同时，我们还需要针对具体的应用场景来设计和实现高效的算法和程序，以达到最优的处理效果和性能。
数据结构-线性表（一）概念及基本操作
北以晨光的博客
09-13 8040
数据结构 线性表（一）基本概念及基本操作 线性表的定义及基本操作以及顺序表示的实现代码
数据结构学习1——线性表定义以及代码
m0_53552112的博客
06-29 1435
数据结构的线性表总代码——串联一章
数据结构：线性表的相关代码
weixin_61626418的博客
01-28 1225
数据结构：线性表
数据结构 线性表-单链表的定义及基本操作
Mi-ronin的博客
03-16 2467
文章目录一.引入二.线性表链式存储结构的定义2.1 顺序结构和链式结构的区别2.2结点定义 一.引入 对于线性表来说，有顺序存储结构，然而顺序结构是有缺点的：插入和删除时需要移动大量元素；因此我们需要解决这一系列问题，线性表的链式存储结构刚好解决了这些问题。 二.线性表链式存储结构的定义 2.1 顺序结构和链式结构的区别 在顺序结构中，每个数据元素只需要存数据元素信息就可以了，在链式结构中，除了要存储元素信息外，还要存储后继元素的存储地址，因此，我们引入了结点。 2.2结点定义 为了表示每个数据元素 a 与
C语言数据结构线性表
qq_55391702的博客
01-17 787
线性表线性表的类型定义 线性表的类型定义 线性表是常用且最简单的一种数据结构。简言之一个线性表是n个数据元素的有限序列。至于每个数据元素的具体含义，在不同的情况下各不相同，它可以是一个数一个符号也可以是一页书，甚至是其他更复杂的信息。 ...
Java数据结构-线性表
qq_51938362的博客
10-16 1562
Java线性表、链表
数据结构线性表所有操作
12-29
根据给定文件的信息，我们可以总结出关于数据结构中线性表的基本操作，这些操作包括创建、遍历、求长度、查询、插入、删除以及销毁线性表等关键知识点。 ### 数据结构简介 #### 1. 线性表定义 线性表是最简单且...
数据结构之线性表教程3.zip
01-02
“数据结构之线性表教程1”可能包含了线性表的基础知识，从基本概念到基本操作的介绍。在“教程3”中，可能会进一步讨论高级话题，如线性表的排序算法（如冒泡排序、插入排序）、线性表的合并、以及线性表在实际编程...
数据结构 线性表实验代码 C语言 数组
11-16
线性表是一种基本且常用的数据结构，它由n（n>=0）个相同类型元素构成的有限序列。在这个实验代码中，我们关注的是使用C语言实现线性表，并采用数组作为底层存储机制。 线性表的基本操作包括： 1. 初始化：创建一...
数据结构 线性表 实验代码 C++ 数组
11-16
线性表是数据结构中最基础也是最常用的一种结构，它是由n（n>=0）个相同类型元素构成的有限序列。在本实验中，我们将聚焦于C++实现的线性表，采用数组作为底层数据结构。 线性表的数组实现，也被称为顺序表，是将...
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 613
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
c语言（7.23）
fhgfyrsg的博客
07-23 512
【代码】c语言（7.23）
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 787
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构：逻辑结构与物理结构
最新发布
Weiki的博客
07-24 929
数据结构：逻辑结构与物理结构
C++实现数据结构：线性表操作示例
线性表是一种基本且常用的数据结构，其特点在于数据元素之间存在一对一的线性关系，即每个元素都有一个前驱元素和一个后继元素，除了第一个元素没有前驱，最后一个元素没有后继。在本章中，我们将深入探讨线性表的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Java程序员十六

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

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

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

打赏作者

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

抵扣说明：

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

余额充值