线性表实现

已于 2024-04-28 17:38:26 修改
阅读量197 收藏
点赞数 8
文章标签： 数据结构
于 2024-04-23 22:24:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74402924/article/details/138140395
版权

顺序表

  • 定义顺序表的结构
typedef int ELemType;
typedef struct
{
	ELemType data[MaxSize];
	int length;
}SqList;
  • 建立顺序表
//建立顺序表函数
void CreateList(SqList* &L, ELemType* a, int n)
{
	L = new SqList;
	for (int i = 0; i < n; i++)
	{
		L->data[i] = a[i];
	}
	L->length = n;
}
  •  销毁线性表
//销毁线性表
void Destory(SqList* L)
{
	delete L;
	cout << "销毁成功" << endl;
}
  •  输出线性表
//输出线性表
void Display(SqList* L)
{
	for (int i = 0; i < L->length; i++)
	{
		cout << L->data[i] << endl;
	}
}
  • 在第i个位置插入元素（i为物理位置）
bool Insert(SqList* L,ELemType e,int i)
{
	i = i - 1;
	if (i<0 || i>L->length || L->length==MaxSize)
		return false;
	for (int j = L->length; j >=i+1 ; j--)
	{
		L->data[j] = L->data[j - 1];
	}
	L->data[i] = e;
	L->length++;
	return true;
}
  • 通过位置删除元素
bool Del(SqList* L, ELemType& e, int i)
{
	i = i - 1;
	if (i<0 || i>L->length - 1)
		return false;
	e = L->data[i];
	for (int j = i; i <= L->length-2; j++)
	{
		L->data[j] = L->data[j + 1];
	}
	
	L->length--;
	return true;
}
  • 按照元素位置查找元素
bool FindByPosition(SqList* L,int i)
{
	i = i - 1;
	if (i<0 || i>L->length - 1) return false;
	int j = 0;
	while (j < i)
	{
		j++;
	}
	cout << L->data[j] << endl;
	
}
  • 按照元素值查找元素
bool FindByValue(SqList* L, ELemType e)
{
	for (int i = 0; i < L->length; i++)
	{
		if (L->data[i] == e)
		{
			cout << L->data[i] << endl;
			cout << "该元素的位置为" << i + 1 << endl;
			return true;
		}
	}
	return false;

}
  • 测试代码
#include<iostream>
using namespace std;
#define MaxSize 50
typedef int ELemType;
typedef struct
{
	ELemType data[MaxSize];
	int length;
}SqList;
//建立顺序表函数
void CreateList(SqList* &L, ELemType* a, int n)
{
	L = new SqList;
	for (int i = 0; i < n; i++)
	{
		L->data[i] = a[i];
	}
	L->length = n;
}
//销毁线性表
void Destory(SqList* L)
{
	delete L;
	cout << "销毁成功" << endl;
}
//输出线性表
void Display(SqList* L)
{
	for (int i = 0; i < L->length; i++)
	{
		cout << L->data[i] << endl;
	}
}
//插入元素,i为物理位置
bool Insert(SqList* L,ELemType e,int i)
{
	i = i - 1;
	if (i<0 || i>L->length || L->length==MaxSize)
		return false;
	for (int j = L->length; j >=i+1 ; j--)
	{
		L->data[j] = L->data[j - 1];
	}
	L->data[i] = e;
	L->length++;
	return true;
}
//删除元素，保存删除的元素
bool Del(SqList* L, ELemType& e, int i)
{
	i = i - 1;
	if (i<0 || i>L->length - 1)
		return false;
	e = L->data[i];
	for (int j = i; i <= L->length-2; j++)
	{
		L->data[j] = L->data[j + 1];
	}
	
	L->length--;
	return true;
}
//按照元素位置查找元素(物理位置)
bool FindByPosition(SqList* L,int i)
{
	i = i - 1;
	if (i<0 || i>L->length - 1) return false;
	int j = 0;
	while (j < i)
	{
		j++;
	}
	cout << L->data[j] << endl;
	
}
//按照元素值查找元素
bool FindByValue(SqList* L, ELemType e)
{
	for (int i = 0; i < L->length; i++)
	{
		if (L->data[i] == e)
		{
			cout << L->data[i] << endl;
			cout << "该元素的位置为" << i + 1 << endl;
			return true;
		}
	}
	return false;

}
int main()
{
	int a[10];
	for (int i = 0; i < 10; i++)
	{
		a[i] = i;
	}
	SqList *L1 = NULL;
	int e=0;
	CreateList(L1, a, 10);
	Insert(L1, 10, 11);
	Display(L1);
	cout << "---------" << endl;
	FindByPosition(L1, 10);
	cout << "----------" << endl;
	FindByValue(L1, 5);
	Destory(L1);

	return 0;
}

链表

单链表

  • 定义单链表的结构
typedef int ElemType;
typedef struct LNode
{
	ElemType data;
	LNode* next;
}LinkNode;
  • 头插入建立单链表
void CreateListF(LinkNode*& L, ElemType* a, int n)
{
	LinkNode* s;
	L = new LinkNode;
	L->next = NULL;
	for (int i = 0; i < n; i++)
	{
		s = new LinkNode;
		s->data = a[i];
		s->next = L->next;
		L->next = s;
	}
}
  • 尾插建立单链表
void CreateListR(LinkNode*& L, ElemType* a, int n)
{
	LinkNode* s, * r;
	L = new LinkNode;
	r = L;//尾插时头结点不能丢
	for (int i = 0; i < n; i++)
	{
		s = new LinkNode;
		s->data = a[i];
		r->next = s;
		r = s;
	}
	r->next = NULL;
}
  • 销毁单链表（方法1）
void DestoryList01(LinkNode* L)
{
	LinkNode* pre, * p;
	pre = L,  p = L->next;
	while (p != NULL)
	{
		delete pre;
		pre = p;
		p = pre->next;
	}
	delete pre;//p 为NULL时pre指向最后一个节点
	cout << "销毁成功" << endl;
}
  • 销毁单链表（方法2）
void DestoryList02(LinkNode* L)
{
	LinkNode* p, * q;
	q = L;
	while ( q != NULL)
	{
		p = q->next;
		delete q;
		q = p;
	}
}
void DestoryList03(LinkNode* L)
{
	LinkNode* p, * q; 
	q = L;
	while (q != NULL)
	{
		p = q;
		q = q->next;
		delete p;
	}
}
  • 输出线性表
void Display(LinkNode* L)
{
	LinkNode* p = L->next;
	while (p != NULL)
	{
		cout << p->data << endl;
		p = p->next;
	}
}
  • 求单链表的长度
void LengthList(LinkNode* L)
{
	LinkNode* p = L;
	int n = 0;
	while (p->next != NULL)
	{
		n++;
		p = p->next;
	}
	cout << n << endl;
	LinkNode* q = L->next;
	int b = 0;
	while (q != NULL)
	{
		b++;
		q = q->next;
	}
	cout << b << endl;
}
  • 按序号求元素的值
bool GetElem(LinkNode* L,int i,ElemType& e)
{
	LinkNode* p = L;
	int j = 0;
	if (i <= 0) return false;
	while (j < i && p != NULL)
	{
		p = p->next;
		j++;
	}
	if (p == NULL)
	{
		return false;
	}
	else
	{
		e = p->data;
		return true;
	}
	
}
  • 查找第i个元素并返回该元素的地址

这个函数在查找和删除操i做经常用，所以建议单独封装成一个函数方便后续使用

LinkNode* FindNode(LinkNode* L, int i)
{
	LinkNode* p = L;
	int j = 0;
	while (j < i && p != NULL)
	{
		p = p->next;
		j++;
	}
	if (p == NULL)
	{
		return NULL;
	}
	else
	{
		return p;
	}
}
  • 插入数据
bool InsertList(LinkNode* L, int i, ElemType e)
{
	if (i <= 0) return false;
	LinkNode* p = FindNode(L, i - 1);
	if (p != NULL)
	{
		LinkNode* s=new LinkNode;
		s->data = e;
		s->next = p->next;
		p->next = s;
		return true;
	}
	else return false;

}
  • 删除数据
bool DelList(LinkNode* L, int i, ElemType& e)
{
	if (i <= 0) return false;
	LinkNode* p = FindNode(L, i - 1);
	if (p != NULL)
	{
		if (p->next == NULL)
		{
			return false;
		}
		else
		{
			LinkNode* s = p->next;
			p->next = s->next;
			e = s->data;
			delete s;
			return true;
		}
	}
}
  • 测试代码
#include<iostream>
using namespace std;
typedef int ElemType;
typedef struct LNode
{
	ElemType data;
	LNode* next;
}LinkNode;
//头插法建立单链表(含头结点)
void CreateListF(LinkNode*& L, ElemType* a, int n)
{
	LinkNode* s;
	L = new LinkNode;
	L->next = NULL;
	for (int i = 0; i < n; i++)
	{
		s = new LinkNode;
		s->data = a[i];
		s->next = L->next;
		L->next = s;
	}
}
//尾插
void CreateListR(LinkNode*& L, ElemType* a, int n)
{
	LinkNode* s, * r;
	L = new LinkNode;
	r = L;//尾插时头结点不能丢
	for (int i = 0; i < n; i++)
	{
		s = new LinkNode;
		s->data = a[i];
		r->next = s;
		r = s;
	}
	r->next = NULL;
}
//初始化线性表
void CreateList(LinkNode*& L)
{
	L = new LinkNode;
	L->next = NULL;
}
//销毁线性表
void DestoryList01(LinkNode* L)
{
	LinkNode* pre, * p;
	pre = L,  p = L->next;
	while (p != NULL)
	{
		delete pre;
		pre = p;
		p = pre->next;
	}
	delete pre;//p 为NULL时pre指向最后一个节点
	cout << "销毁成功" << endl;
}
void DestoryList02(LinkNode* L)
{
	LinkNode* p, * q;
	q = L;
	while ( q != NULL)
	{
		p = q->next;
		delete q;
		q = p;
	}
}
void DestoryList03(LinkNode* L)
{
	LinkNode* p, * q; 
	q = L;
	while (q != NULL)
	{
		p = q;
		q = q->next;
		delete p;
	}
}
//判断线性表是否为空
bool ListEmpty(LinkNode* L)
{
	return L->next;
}
//输出线性表
void Display(LinkNode* L)
{
	LinkNode* p = L->next;
	while (p != NULL)
	{
		cout << p->data << endl;
		p = p->next;
	}
}
//求线性表的长度
void LengthList(LinkNode* L)
{
	LinkNode* p = L;
	int n = 0;
	while (p->next != NULL)
	{
		n++;
		p = p->next;
	}
	cout << n << endl;
	LinkNode* q = L->next;
	int b = 0;
	while (q != NULL)
	{
		b++;
		q = q->next;
	}
	cout << b << endl;
}
//按序号求元素的值
bool GetElem(LinkNode* L,int i,ElemType& e)
{
	LinkNode* p = L;
	int j = 0;
	if (i <= 0) return false;
	while (j < i && p != NULL)
	{
		p = p->next;
		j++;
	}
	if (p == NULL)
	{
		return false;
	}
	else
	{
		e = p->data;
		return true;
	}
	
}
//查找第i个元素点并返回该节点的地址
LinkNode* FindNode(LinkNode* L, int i)
{
	LinkNode* p = L;
	int j = 0;
	while (j < i && p != NULL)
	{
		p = p->next;
		j++;
	}
	if (p == NULL)
	{
		return NULL;
	}
	else
	{
		return p;
	}
}
//插入数据
bool InsertList(LinkNode* L, int i, ElemType e)
{
	if (i <= 0) return false;
	LinkNode* p = FindNode(L, i - 1);
	if (p != NULL)
	{
		LinkNode* s=new LinkNode;
		s->data = e;
		s->next = p->next;
		p->next = s;
		return true;
	}
	else return false;

}
//删除数据
bool DelList(LinkNode* L, int i, ElemType& e)
{
	if (i <= 0) return false;
	LinkNode* p = FindNode(L, i - 1);
	if (p != NULL)
	{
		if (p->next == NULL)
		{
			return false;
		}
		else
		{
			LinkNode* s = p->next;
			p->next = s->next;
			e = s->data;
			delete s;
			return true;
		}
	}
}
int main()
{
	int a[10];
	for (int i = 0; i < 10; i++)
	{
		a[i] = i + 1;
	}
	int e;
	LinkNode* b;
	LinkNode* L1 = NULL;
	CreateListR(L1, a, 10);
	Display(L1);
	cout << "----" << endl;
	LengthList(L1);
	cout << "----" << endl;
	GetElem(L1, 5, e);
	cout << e << endl;
	cout << "----" << endl;
	b = FindNode(L1, 5);
	cout << b->data << endl;
	cout << "----" << endl;
	InsertList(L1, 11, 11);
	Display(L1);
	cout << "----" << endl;
	DelList(L1, 11, e);
	cout << e << endl;
	DestoryList01(L1);
	return 0;
}

双链表

  • 头插法
void CreateListF(DLinkNode*& L, ElemType* a, int n)
{
	L = new DLinkNode;
	DLinkNode* s;
	L->prior = L->next = NULL;
	for (int i = 0; i < n; i++)
	{
		s = new DLinkNode;
		s->data = a[i];//s->data=*(a+i);
		s->next = L->next;
		if (L->next != NULL)
		{
			L->next->prior = s;
		}
		L->next = s;
		s->prior = L;
	}
}
  • 尾插法
void CreateListR(DLinkNode*& L, ElemType* a, int n)
{
	L = new DLinkNode;
	DLinkNode* r = L, * s;
	for (int i = 0; i < n; i++)
	{
		s = new DLinkNode;
		s->data = a[i];
		r->next = s;
		s->prior = r;
		r = s;
	}
	r->next = NULL;
}

 

循环链表

循环单链表是将尾节点的next指针域指向头节点，判断尾节点的条件是p->next==NULL

循环双链表是将尾部节点的next指针域指向头节点，将头节点的prior指针域指向尾节点，判断尾节点的条件为p->next==NULL,循环双链表中可以通过p->prior快速找到尾节点

point to PG
关注
  • 8
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
斗地主发牌程序——线性表实现
11-09
用线性表实现斗地主发牌程序，本人水平低劣，可供数据结构初学者参考，如有错误可留言指出
利用线性表实现一个一元多项式
12-07
可以使用链表实现，也可以使用顺序表实现 具体要求如下： 能够实现一元多项式的输入和输出 能够进行一元多项式相加 能够进行一元多项式相减 能够计算一元多项式在x处的值 能够计算一元多项式的导数（选作） ...
数据结构线性表实现学生信息管理系统
qq_44024359的博客
10-22 2万+
数据结构线性表实现学生信息管理系统 方法一：顺序表实现 #include <stdio.h> #include <iostream> #include <stdlib.h> #include <string.h> #define MAXSIZE 1000 #define OVERFLOW -1 using namespace std; type...
基于链式存储结构的线性表实现-数据结构（C语言）
kim的博客
04-04 2018
实验名称: 基于链式存储结构的线性表实现 目录 一、实验目的 二、实验环境安装设置 三、实验任务 四、程序框架 五、程序完整代码 六、程序测试 一、实验目的 加深对线性表的概念、基本运算的理解； 熟练掌握线性表的逻辑结构与物理结构的关系； 物理结构采用链式存储结构,熟练掌握链式存储结构各种基本运算的实现。 二、实验环境安装设置 1. 启动DevCPP在E：建立工作区MyCpp，所有的程序源码都存放在该文件夹下。 三、实验任务 认真研读框架程序，根据提供的实验框架（框架
线性表java实现
qq_41044209的博客
06-24 1046
通过数组实现，查询直接根据索引（index）查询，效率比较高；增删的效率比较低，因为需要大量的移动元素的位置，一旦创建，长度固定，当长度等于数组长度时，如果想要再插入数据就需要扩容处理。...
基于顺序存储结构的线性表实现-数据结构（C语言）
kim的博客
05-16 682
实验名称: 基于顺序存储结构的线性表实现 一、实验目的 加深对线性表的概念、基本运算的理解； 熟练掌握线性表的逻辑结构与物理结构的关系； 物理结构采用顺序表,熟练掌握线性表的基本运算的实现。 二、实验任务 认真研读框架程序，根据提供的实验框架（框架可以直接运行），构造一个具有菜单的功能演示系统。根据功能要求实现下面7个线性表操作操作，约定下面i位置从1开始： void ListInitiate(SeqList*L);//初始化线性表 int ListLength(SeqList*L);//
基于顺序存储结构的线性表实现-数据结构C语言
kim的博客
04-04 1638
实验名称: 基于顺序存储结构的线性表实现 目录 一、实验目的 二、实验环境安装设置 三、实验任务 四、程序框架 五、程序完整代码 六、程序测试 一、实验目的 加深对线性表的概念、基本运算的理解； 熟练掌握线性表的逻辑结构与物理结构的关系； 物理结构采用顺序表,熟练掌握线性表的基本运算的实现。 二、实验环境安装设置 1. 启动DevCPP在E：建立工作区MyCpp，所有的程序源码都存放在该文件夹下。 三、实验任务 认真研读框架程序，根据提供的实验框架（框架可以直接运
数据结构-排序线性表实现学生管理系统
Grit的博客
05-10 364
数据结构-排序线性表实现学生管理系统 - Timcode - 博客园 (cnblogs.com)
[数据结构][C++]使用线性表实现一个通讯录
Keith_Prime的博客
09-21 8013
使用线性表实现一个通讯录，通讯录内容包含学号、姓名、电话三项数据。完成通讯录数据的建立，纪录插入和删除功能。   #include &lt;iostream.h&gt; #include &lt;conio.h&gt; #include &lt;iomanip.h&gt; #include &lt;string.h&gt; //--------------------------------...
python实现线性表
热门推荐
liulanba的博客
02-09 2万+
线性表的定义： 线性表是具有相同数据类型的n(n.>=0)个数据元素的有限序列，其中n为表长，n=0时表示该表是一个空表，一般表示为： L=(a1,a2…an-1,an) 逻辑特性：a1是表头元素，an是表尾元素，除了表头元素，每个元素有且仅有一个直接前驱，除了表尾元素，每个元素有且仅有一个直接后继。 线性表的特点： –表中元素个数有限。 –表中元素具有逻辑上的顺序性，在序列中各元素排列有其先后次序。 –表中元素都是数据元素，每个元素都是单个元素。 –表中元素的数据类型都相同，即每个元素占用的存储空间
线性表实现增删改查等基本操作
DRZ_2000的博客
02-03 2332
线性表实现 增删改查 等基本操作 当数据结构是线性结构时，我们可以用顺序表或者是链表实现，此处我们先讨论顺序表的一些基本操作 首先为了便于程序的演示以及说明，我们先定义相应的数据结构如下： typedef struct Vector { int size, length; //顺序表的总体大小以及现有长度 int *data; //data指向存储数据数组的首地址...
用线性表实现一个一元多项式Polynomial
11-22
该源程序是数据结构的代码实现：用线性表实现一个一元多项式Polynomial
线性表实现一个多项式.rar
03-30
数据结构课程中要求用线性表实现一个多项式，这是完整的实验报告.
堆的实现与堆排序
酷酷学!!!的博客
05-19 1141
本篇旨在介绍二叉树中特殊结构堆, 以及堆的实现与应用更多文章 博客主页:酷酷学!!!点击关注 一起加油~int _size;}Heap;// 堆的销毁// 堆的插入// 堆顶数据的删除// 取堆顶的数据// 堆的数据个数// 堆的判空任意节点的值大于或等于其子节点的值（大顶堆）或小于或等于其子节点的值（小顶堆）。二叉树堆是一个完全二叉树，即除了最后一层外，其他层都是满的，并且最后一层的节点都靠左排列。
数据结构-线段树
knoci的博客
05-19 1000
线段树（Segment Tree）是一种数据结构，它主要用于维护区间信息（要求满足结合律），它可以实现 𝑂(log⁡𝑛) 的区间修改，还可以同时支持多种操作（加、乘）。从数据结构的角度来说，线段树是用一个完全二叉树来存储对应于其每一个区间（segment）的数据。该二叉树的每一个结点中保存着相对应于这一个区间的信息。同时，线段树所使用的这个二叉树是用一个数组保存的，与堆（Heap）的实现方式相同。例如，给定一个长度为N的数组arr，其所对应的线段树TT的根结点代表整个数组所在的区间对应的信息，及。
数据结构 —— 栈 与 队列
最新发布
2301_78957570的博客
05-22 407
栈（Stack）是一种特殊的线性数据结构，它遵循后进先出（LIFO，Last In First Out）的原则。栈只允许在一端插入和删除数据，这一端被称为栈顶（top），另一端被称为栈底（bottom）。就像弹匣一样，先压进去的子弹会最后被发射，最后压进去的子弹反而最先被发射。
数据结构_栈和队列学习
weixin_46571256的博客
05-19 449
简单易实现，空间固定，可能造成空间浪费或溢出。：检查栈顶指针是否为NULL。
利用线性表实现通讯录管理
03-25
A：通讯录管理可以通过线性表来实现，其中一个常用的线性表是数组。具体实现方法如下： 1.定义一个结构体，包含通讯录中一个人的信息，比如姓名、电话号码等。 2.定义一个数组来存储这些结构体，数组大小可以根据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值