数据结构 第二章 线性表

最新推荐文章于 2021-12-27 16:22:17 发布
最新推荐文章于 2021-12-27 16:22:17 发布
阅读量266 收藏 2
点赞数 1
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45903765/article/details/107317956
版权

线性表的代码

#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量
#define LISTINCREMENT 10 //线性表存储空间的分配增量
#define Maxsize 10//静态分配顺序表的最大长度
#define ElemType int
#define TURE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#include<stdio.h>
#include<stdlib.h>
typedef struct 
{//线性表静态分配顺序存储结构
	ElemType data[Maxsize];//大小无法改变
	int length;//顺序表当前长度
}SeqList;
typedef struct 
{//线性表的动态分配顺序存储结构
	ElemType* elem; //存储空间基址
	int length;//当前长度
	int listsize;//当前分配的存储容量(以sizeof(ElemType))为单位
}SqList;
typedef struct LNode
{//线性表的单链表存储结构
	ElemType data;
	struct LNode* next;
}LNode,*LinkList;
typedef struct DuLNode
{//线性表的双向链表存储结构
	ElemType data;
	struct DuLNode* prior, * next;
}DuLNode,*DuLinkList;

int InitList_Seq(SeqList& L)
{//初始化一个顺序表
	int i;

	for (i = 0; i < Maxsize; i++)
	{//防止脏数据
		L.data[i] = 0;
	}
	L.length = 0;//顺序表初始长度
	return OK;
}
int InitList_Sq(SqList& L)
{//构造一个空的线性表L

	L.elem = (ElemType*)malloc(sizeof(ElemType) * LIST_INIT_SIZE);
	if (!L.elem)
	{
		return OVERFLOW;
	}
	L.length = 0;//顺序表初始长度为0，空表
	L.listsize = LIST_INIT_SIZE;
	return OK;
}
int Increasesize(SqList& L, int len)
{//动态增加顺序表长度
	ElemType* p;
	int i;

	p = L.elem;
	L.elem = (ElemType*)malloc(sizeof(ElemType) * (L.length + len));
	if (!L.elem)
	{//分配失败
		return ERROR;
	}
	for (i = 0; i < L.length; i++)
	{//数据复制
		L.elem[i] = p[i];
	}
	L.listsize = L.length + len;//更新线性表长度
	free(p);//释放辅助空间
	return OK;
}
int Seq_Insert(SeqList& l, int i, ElemType e)
{//在静态分配线性表的第i个位置插入e
	int j;
	if (i<1 || i>l.length+1)
	{
		return FALSE;
	}
	if (l.length >= Maxsize)
	{
		return FALSE;
	}
	for (j = l.length; j >= i; j--)
	{
		l.data[j] = l.data[j - 1];
	}
	l.data[i - 1] = e;
	l.length++;
	return OK;
}
int Sq_Insert(SqList& l, int i,ElemType e)
{//在动态分配线性表的第i个位置插入e
	ElemType* p,* q;
	if (i<1 || i>l.length + 1)
	{
		return FALSE;
	}
	if (l.length >= l.listsize)
	{
		Increasesize(l, LISTINCREMENT);
	}
	q = l.elem + (i - 1);//q指示插入位置
	p = l.elem + (l.length - 1);
	for (; p >= q; --p)
	{//插入元素之后元素后移
		*(p + 1) = *p;

	}
	*q = e;//插入e
	l.length++;
	return OK;
}

int Seq_Delete(SeqList& l, int i, ElemType&  e)
{//在静态分配线性表的第i个位置删除
	int j;
	if (i<0 || i>l.length)
	{
		return FALSE;
	}
	e = l.data[i - 1];
	for (j = i; j < l.length; j++)
	{
		l.data[j - 1] = l.data[j];
	}
	l.length--;
	return OK;
}
int Sq_Delete(SqList& l, int i, ElemType& e)
{//在动态分配线性表的第i个位置删除
	ElemType* p, * q;
	if (i<0 || i>l.length)
	{
		return FALSE;
	}
	p = l.elem + (i - 1);
	e = *p;
	q = l.elem + (l.length - 1);
	for (p++; p <= q; p++)
	{
		*(p - 1) = *p;
	}
	l.length--;
	return OK;
}
int Seq_GetElem(SeqList l, int i, ElemType& e)
{//按位查找静态分配线性表
	if (i<0 || i>l.length)
	{
		return ERROR;
	}
	e = l.data[i - 1];
	return OK;
}
int Sq_GetElem(SqList l, int i, ElemType& e)
{//按位查找动态分配线性表
	if (i<0 || i>l.length)
	{
		return ERROR;
	}
	e = l.elem[i - 1];
	return OK;
}
void Sq_LocateElem(SqList l, int& i, ElemType e)
{//按值查找动态分配线性表
	for (i = 0; i < l.length; i++)
	{
		if (l.elem[i] == e)
			break;
	}
	i = i + 1;
}
int CreateList_L(LinkList& l)
{//逆向建立单链表
	LinkList L;
	ElemType x;

	l = (LinkList)malloc(sizeof(LNode));//头结点
	if (!l)
	{
		return ERROR;
	}
	l->next = NULL;
	printf("逆序输入结点数据，输入999结束");
	scanf_s("%d", &x);
	while (x != 999)
	{
		L = (LinkList)malloc(sizeof(LNode));
		L->next = l->next;
		L->data = x;
		l->next = L;
		scanf_s("%d", &x);
	}
	return TURE;
}
int LinkList_TailInsert(LinkList& l)
{//尾插法创建单链表
	ElemType x;
	LinkList L;
	l = (LinkList)malloc(sizeof(LNode));
	l->next = NULL;
	if (!l)
	{
		return ERROR;
	}
	printf("顺序输入结点数据，输入999结束");
	scanf_s("%d", &x);
	while (x != 999)
	{
		L = (LinkList)malloc(sizeof(LNode));
		L->data = x;
		L->next = NULL;
		l->next = L;
		scanf_s("%d", &x);
	}
	return OK;
}
int GetElem_L(LinkList L, int i, ElemType& e)
{
	int j = 1;//计数器
	LinkList p;
	p = L->next;
	while (p && j < i)
	{
		p = p->next;
		j++;
	}
	if (!p || j > i)
	{
		return ERROR;
	}
	e = p->data;
	return OK;
}
int ListInsert(LinkList& l, int i, ElemType e)
{
	LNode* p, * s;//p指向当前扫描到的结点
	int j = 0;//当前p指向的是第几个结点
	
	if (i < 1)
	{
		return ERROR;
	}
	p = l;//l指向头结点，头结点是第零个结点(不存结点)
	while (p != NULL && j < i - 1)
	{//循环找到第i-1个结点
		p = p->next;
		j++;
	}
	if (p == NULL || j > i - 1)
	{
		return ERROR;
	}
	s = (LinkList)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return OK;
}
int Listinsert(LinkList& l, int i, ElemType e)
{
	LinkList p, s;
	int j = 1;
	if (i < 1)
	{
		return ERROR;
	}
	if (i == 1)
	{//插入第一个结点的的操作和其他结点不同
		s = (LinkList)malloc(sizeof(LNode));
		s->data = e;
		s->next = l;
		l = s;
		return OK;
	}
	p = l;
	while (p != NULL && j < i - 1)
	{//循环找到第i-1个结点
		p = p->next;
		j++;
	}
	if (p == NULL || j > i - 1)
	{
		return ERROR;
	}
	s = (LinkList)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return OK;
}
int ListDelete(LinkList& l, int i, ElemType e)
{
	LNode* p, * q;//p指向当前扫描到的结点
	int j = 0;//当前p指向的是第几个结点

	if (i < 1)
	{
		return ERROR;
	}
	p = l;//l指向头结点，头结点是第零个结点(不存结点)
	while (p != NULL && j < i - 1)
	{//循环找到第i-1个结点
		p = p->next;
		j++;
	}
	if (p == NULL || j > i - 1)
	{
		return ERROR;
	}
	if (p->next == NULL)
	{
		return ERROR;
	}
	q = p->next;//令q指向被删除结点
	e = q->data;
	p->next = q->next;
	free(q);
	return OK;
}
int InitDuLinkList(DuLinkList& l)
{
	l = (DuLinkList)malloc(sizeof(DuLNode));
	if (!l)
	{
		return ERROR;
	}
	l->prior = NULL;
	l->next = NULL;
	return OK;
}
DuLNode *GetElemP_DuL(DuLinkList l, int i)
{
	int j = 1;
	DuLinkList p;
	p = l->next;
	while (j < i)
	{
		p = p->next;
	}
	return p;
}
int ListInsert_Dul(DuLinkList& l, int i, ElemType e)
{
	DuLinkList p, s;
	if (i < 1)
	{
		return ERROR;
	}
	if (!(p = (GetElemP_DuL(l, i))));
	{
		return ERROR;
	}
	s = (DuLinkList)malloc(sizeof(DuLNode));
	if (!s)
	{
		return ERROR;
	}
	s->data = e;
	s->prior = p->prior;
	p->prior->next = s;
	s->next = p;
	p->prior = s;
	return OK;
}
int ListDelete_Dul(DuLinkList& l, int i, ElemType& e)
{
	DuLinkList p, s;
	if (i < 1)
	{
		return ERROR;
	}
	if (!(p = (GetElemP_DuL(l, i))));
	{
		return ERROR;
	}
	e = p->data;
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free(p);
	return OK;
}
int InitList(LinkList& l)
{
	l = (LinkList)malloc(sizeof(LNode));
	if (!l)
	{
		return ERROR;
	}
	l->next = l;
	return OK;
}
int InitDulist(DuLinkList& l)
{
	l = (DuLinkList)malloc(sizeof(DuLNode));
	if (!l)
	{
		return ERROR;
	}
	l->next = l;
	l->prior = l;
	return OK;
}
int main()
{
	SeqList l;//静态分配
	SqList L;//动态分配
	LinkList LL;//单链表
	DuLinkList ll;//双向链表
	int i;
	ElemType e;

	InitList_Seq(l);
	InitList_Sq(L);
	printf("输入在静态分配存储线性表插入位置和插入内容\n");
	scanf_s("%d,%d", &i, &e);
	Seq_Insert(l, i, e);
	printf("输入在静态分配存储线性表删除位置\n");
	scanf_s("%d", &i);
	Seq_Delete(l, i,e);
	printf("输入在动态分配存储线性表插入位置和插入内容\n");
	scanf_s("%d,%d", &i, &e);
	Sq_Insert(L, i, e);
	printf("输入在动态分配存储线性表删除位置\n");
	scanf_s("%d", &i);
	Sq_Delete(L, i, e);
	printf("输入在静态分配存储线性表中查找的位序\n");
	scanf_s("%d", &i);
	Seq_GetElem(l, i, e);
	printf("输入在动态分配存储线性表中查找的位序\n");
	scanf_s("%d", &i);
	Sq_GetElem(L, i, e);
	printf("输入在动态分配存储线性表中查找的内容\n");
	scanf_s("%d", &e);
	Sq_LocateElem(L, i, e);
	printf("头插法建立单链表\n");
	CreateList_L(LL);
	printf("尾插法建立单链表\n");
	LinkList_TailInsert(LL);
	printf("查找单链表的第i个位置\n");
	printf("输入位置i");
	scanf_s("%d", &i);
	GetElem_L(LL, i,e);
	printf("在(带头结点的)单链表第i个位置插入e，输入i和e\n");
	scanf_s("%d,%d", &i, &e);
	ListInsert(LL, i, e);
	printf("在(不带头结点的)单链表第i个位置插入e，输入i和e\n");
	scanf_s("%d,%d", &i, &e);
	Listinsert(LL, i, e);
	printf("在(带头结点的)单链表第i个位置删除e，输入i和e\n");
	scanf_s("%d,%d", &i, &e);
	ListDelete(LL, i, e);
	printf("初始化双向循环链表");
	InitDuLinkList(ll);
	printf("在带头结点的双向链表中第i个位置插入e");
	scanf_s("%d,%d", &i, &e);
	ListInsert_Dul(ll, i, e);
	printf("在带头结点的双向链表中第i个位置删除");
	scanf_s("%d", &i);
	ListDelete_Dul(ll, i, e);
	printf("初始化循环单链表");
	InitList(LL);
	printf("初始化循环双链表");
	InitDulist(ll);
	return 0;
}
雕花墨
关注
数据结构---线性表
zzqingyun的博客
01-10 1953
静态分配int length;}SqList;L.length=0;return 0;动态分配#define MAXSIZE 5 //MAXSIZE是根据实际问题定义的足够大的整数常量//定义了一个指针变量存放地址int length;}SqList;//定义顺序表类型SqList L;//在C++中也可以使用new,和delete//释放空间return 0;增加数组空间的长度int length;}SqList;
JDBC全解(个人见解,不成熟地方还请谅解和补充，O(∩_∩)O谢谢！)
showpo的博客
07-27 594
一、Java Database Connectivity(JDBC)： - JDBC能使Java访问数据库,是Java访问数据库的解决方案(*). 1.SUN发明了java,规定了JDBC接口. 2.SUN提供了一个接口DriverManager(驱动管理器)继承JDBC接口. 3.DM接口创建"Driver驱动"实现类由数据库厂商提供的. 1)JDBC工作过程: 1.注册
顺序表
qq_40950183的博客
09-24 149
看过了很多讲数据结构的文章,有种千篇一律的感觉,套路和顺序大致相同.于是决定,自己写的时候使用一种新的方式把它呈现给大家. 将采用提示–思考–代码及注释的方式,在看具体的代码实现之前,大家可以通过提示先试着自己写,然后再看代码实现.代码均使用C++!!! 结构体定义 提示: 应该有存放数据的地方 应该记录已存放了多少个元素 表应该有上限 代码: typedef struct { int *...
顺序表的定义与实现
sinat_40912840的博客
06-23 1139
template &lt;class elemtype&gt;class seqlist:public list&lt;elemtype&gt;{ private :  elemtype *data;int maxsize;             int currentlength;                void doublepace();public:          seqlis...
【数据结构1】顺序表
weixin_34345753的博客
12-28 194
顺序表的基本概念 1 静态存储 2 动态存储 顺序表的基本操作 1 插入操作 2 删除操作 3 查找操作 4 顺序表并集 5 顺序表合并 1 顺序表的基本概念 　　顺序存储的线性表称为顺序表。表中元素的逻辑顺序与物理顺序相同。 　　假设顺序表L存储的起始位置是b，每个数据元素所占用存储空间大小...
第二章 线性表
weixin_51001898的博客
12-03 434
一个线性表是n个数据元素的有限序列 线性结构是一个数据元素的有序集： 集合中必存在唯一的一个“第一元素” 集合中必存在唯一的一个“最后元素” 除最后元素以外，均有唯一的后继 除第一元素之外，均有唯一的前驱 两线性表的并集 （扩大线性表La，将存在于线性表Lb中而不存在线性表La中的数据元素插入到线性表La中） void Union(List&La,List Lb){ La_Len=ListLength(a);Lb_Len=ListLength(b); for(i=1;i<=Lb_L
数据结构第二章线性表c++代码
07-14
本压缩包包含的数据结构第二章线性表的C++代码，重点展示了数据结构中的几个基本概念，如静态顺序表、动态顺序表、单链表和双链表。这些数据结构在实际编程中有着广泛的应用，例如在操作系统、数据库系统、编译器...
专升本数据结构第二章 线性表.pdf
最新发布
01-14
线性表是数据结构的基础部分，它是一种特殊的数据组织形式，由n（n>=0）个相同类型的数据元素构成的有限序列。线性表的每个元素都有一个直接前驱和直接后继，除了首元素（没有前驱）和尾元素（没有后继）。这种结构...
数据结构第二章线性表.pdf
09-30
数据结构第二章线性表.pdf 本章主要介绍了线性表的逻辑结构、顺序存储结构和链式存储结构，并对顺序表和链表进行了比较。学习目的要求学生能够熟悉线性表的逻辑结构和各种存储表示方法，以及定义在逻辑结构上的各种...
数据结构第二章线性表习题.doc
09-24
数据结构第二章线性表习题 本节习题涵盖了数据结构第二章线性表的主要知识点，包括线性表的定义、顺序表和链表的存储结构、插入、删除、查找等基本操作的时间复杂度分析，以及栈的实现和应用。 1. 线性表是有限...
数据结构第二章线性表
03-03
线性表的定义和基本操作 线性表的顺序存储结构 线性表的链式存储结构 线性表的应用举例
《数据结构之线性表合并操作》
self_realian的博客
07-26 2157
#include       using namespace std;      #define LIST_INIT_SIZE    100   //线性表存储空间的初始分配量      #define LISTINCREMENT   10  //线性表存储空间的分配增量      typedef int ElemType;      //定义别名      typedef i
数据结构复习（2.线性表）
qq_53635710的博客
12-27 1378
1.线性结构特点： 1.只有一个首节点和尾节点 2.除了首位节点之外，其他节点只有一个直接前驱和直接后继 线性结构反映节点间的逻辑关系是一对一的 线性表的直接定义：用数据元素的有限序列表示 eg：(a1,a2,,,,,,,ai-1,ai,ai+1,,,,,,,an) a1处：线性起点 ai-1是ai的直接前驱 ai+1是ai的直接后继 下标是元素的符号，表示元素在表中的位置 n=0时称为空表，记做L=（） n为线性表的...
线性表顺序表示和实现（C语言)
热门推荐
世纪末的架构师的博客
09-23 4万+
线性表顺序表示和实现 线性表是最常用且最简单的一种数据结构。简而言之，一个线性表是n个数据元素的有限序列 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。 实现工具：dev 顺序表示要实现的功能： 1.构造一个空的线性表 2. 对线性表进行赋值 3. 对线性表进行销毁 4. 对线性表进行重置 5. 判断线性表是否为空 6. 获取线性表的长度 7. 获取线性表某一位置对应的元素 8. 在线性表某一位置插入元素 9. 删除线性表某一位置的元素 10. 求线性表某一元素的前驱 11. 求线
数据结构与算法＜6＞——线性表的顺序存储结构（顺序表的具体操作）
元气少女硕硕子的博客
08-05 2321
一.顺序表的示意图 #define LIST INIT SIZE 100 //线性表存储空间的初始分配量；就是数组多大，这里定义了100 typedef struct{ Elem Type elem[LIST INIT SIZE]; //用一维数组来装数据元素，这里是Elem类型，也可以是别的类型 int length; //当前长度 }SqList; 这个就相当于定义了一个顺序表 L，它是一个SqList型的变量
线性表顺序存储及相关操作（创建，插入，删除，遍历）
be_a_hacker的博客
01-14 3014
线性表类型的定义 线性表是由同类数据元素构成的有序序列的线性结构 表中元素个数（n>=0）称为线性表的长度,n=0时称为空表。 在复杂线性表中，一个数据元素可以由若干个数据项（item）组成。这种情况下，常把数据元素称为记录（record），含有大量记录的线性表称为文件（file）。 线性表中的数据元素可以是各种各样的，但是同一线性表中元素必定具有相同的特性，即统一数据对象相邻元素之间存在着序偶关系。 抽象数据类型线性表的定义： ADT List{ 数据对象:D={ai|ai∈ElemSe
数据结构--线性表
驰骋翱翔
11-22 759
数据结构是相互之间一种或多种关系的数据元素的集合，它是针对具体的问题提出的，我们在分析问题的过程中一般要经历：根据问题建立数学模型（逻辑结构），在计算机中建立相应的存储结构，设计算法实现解决问题的方法。线性表是属于存储结构的一种基本类型。                                                             一个问题可以通过一种逻辑结构表示
数据结构之线性表的初始化及其操作
令狐_JackieHao的博客
04-03 3万+
一.准备工作 ： 1.定义存储空间的分配量 #define MAXSIZE 10 2.定义结果状态函数Status 返回成功失败的状态。 误区：刚开始我把Status理解成了C语言的一个关键字，后来才知道Status是一个用户自定义函数，是定义的一种类型。 用来表示成功或失败的状态。 typedef int Status;//Status是函数的类型 3.定义ElemType 函数类型，需要根...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值