数据结构-线性表

最新推荐文章于 2022-06-16 11:20:18 发布
最新推荐文章于 2022-06-16 11:20:18 发布
阅读量485 收藏 1
点赞数 1
分类专栏： 数据结构学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43558339/article/details/103321036
版权

目录

线性表的基本概念

线性表的定义

线性表是一个具有相同特性的数据元素的有限序列。
//相同特性：所有元素属于同一数据类型。
序列：数据元素由逻辑序号唯一确定，一个线性表中可以有相同元素个数。
逻辑表示：（a1,a2,…,ai,ai+1,…,an）,ai表示第i（i表示逻辑位序）个元素

顺序存储结构

顺序表

概念：把线性表中所有元素按照顺序存储方法存储。按逻辑顺序依次存储到存储器中一片连续的存储空间中。
类型定义：

typedef struct{
ElemType data[MaxSize];
int length;
}SqList;//data存放元素，length存放线性表实际长度
顺序表运算实现

1、建立顺序表

void CreateList(SqList *&L,ElemType a[],int n)
{
    int i;
    L=(SqList *)malloc(sizeof(SqList));
    for(i=0;i<n;i++)
    L->data[i]=a[i];
    L->length=n;
  }

2、初始化线性表InitList(L)

void InitList(SqList *&L)
{    L=(SqList *)malloc(sizeof(SqList));//分配存放线性表的顺序表空间
	L->length=0;
}

3、判断是否为空表ListEmpty(L)

bool ListEmpty(SqList *L)
{
	return(L->length==0);
}

4、求线性表长度ListLength(L)

int ListLength(SqList *L)
{
	return(L->length);
}

5、输出线性表DispList（L）

void DispList(SqList *L)
{
	int i;
	if(ListEmpty(L)) return;
	for(i=0;i<L->length;i++)
		printf("%c",L->data[i]);
	printf("\n");
}

6、求某个数据元素值GetElem（L,i,e）

bool GetElem(SqList *L,int i,ElemType &e)
{
	if(i<1||i>L->length) return false;
	e=L->data[i-1];
	return true;
}

7、按元素值查找LocateElem(L,e)

int LocateElem(SqList *L,ElemType e)
{
	int i=0;
	while(i<L->length&&L->data[i]!=e)
	i++;
	if(i>=length) return 0;
	else return i+1;//返回逻辑位序

8、插入数据元素ListInsert(L,i,e)

bool ListInsert(SqList *&L,int i,ElemType e)
{
	int j;
	if(i<1||i>L->length+1) return false;//参数错误时返回false
	i--;
	for(j=L->length;j>i;j--)//将data[i...n-1]元素后移一个位置
	L->data[j]=L->data[j-1];
	L->data[i]=e;//插入元素e
	L->length++;//别忘了这个
	return true;

当i=n+1，移动次数为0；当i=1，移动次数为n，达到最大值，算法最坏复杂度为O（n）
平均情况分析：
在插入元素ai时，若为等概率情况，则pi=1/(n+1)，共移动N=n-i+1个元素，p*N可得，平均移动次数为n/2
平均时间复杂度为O（n）
9、删除数据元素ListDelete(L,i,e)

bool ListDelete(SqList *&L,int i,ElemType &e)
{	int j;
	if(i<1||i>L->length)//参数错误时返回false
		return false;
	i--;//将逻辑序号转化为物理序号
	e=L->data[i];
	for(j=i;j<L->length-1;j++)
	L->data[j]=L->data[j+1];
	L->length--;//顺序表长度减1
	return true;

当i=n时，移动次数为0；当i=0时，移动次数为0；
平均情况分析：等概率情况，pi=1/n；共移动n-i个元素
所以在长度为n的线性表中删除一个元素时平均移动次数：n-1/2
平均时间复杂度为O（n）

顺序表算法设计

例题：已知长度为n的线性表A采用顺序存储结构。设计一个时间复杂度为O（n）、空间复杂度为O（1）的算法，该算法删除线性表中所有值为x的数据元素。
解法一：//用k记录顺序表中不等于x的元素个数
思路：扫描顺序表A，重建A只包含不等于x的元素。

void delnode1(SqList *&A,ElemType x)
{
	int k=0,i;//k记录值不等于x的元素个数
	for(i=0;i<A->length;i++)
		if(A->data[i]!=x)
		{A->data[x]=A->data[i];
		k++;}
		A->length=k;

解法二：//用k记录顺序表中等于x的元素个数
思路：将不为x的元素前移k个位置，最后修改A的长度

void delnode2(SqList *&A,ElemType x)
{	int k=0,i=0;//k记录值等于x的元素个数
	while(i<A->length)
	{	if(A->data[i]==x)//当前元素值为x时k增1
		k++;
		else
		A->data[i-k]=A->data[i];
		i++;
	}
	A->length-=k;

例2：把第一个元素左边放比它小的，右边放比它大的
解法一：

void move1(SqList *&L)
{	int i=0,j=L->length-1;ElemType tmp;
	ELemType pivot-L-<data[0];
	while(i<j){
	while(i<j&&L->data[j]>pivot)
	j--;
	while(i<j&&L->data[i]<=pivot)
	i++;
	if(i<j)
	{    tmp=L->data[i];
		L->data[i]=L->data[j];
		L->data[j]=tmp;
	}
}
tmp=L->data[0];
L->data[0]=L->data[j];
L->data[j]=tmp;
}

解法二：j从后向前找小于等于pivot的元素：前移
i从前向后找大于pivot的元素：后移

void move2(SqList *&L)
{	int i=0,j=L->length-1;
	ElemType pivot=L->data[0];
	while(i<j)
	{	while(j>i&&L->data[j]>pivot)
		j--;
		L->data[i]=L->data[j];
		while(i<j&&L->data[i]<=pivot)
		i++;
		L->data[j]=L->data[i];
	}
	L->data[i]=pivot;
}

解法二比解法一好，因为移动次数少

线性表的链式存储结构

链表

概念：每个节点都有唯一的前趋节点和后继节点
单链表增加头节点优点：
1、第一个节点操作和其他节点一致，无需特殊处理
2、无论链表是否为空，都有一个头节点，空表和非空表处理统一
存储密度=（节点数据本身占用空间）/（节点占用的空间总量）

单链表

typedef struct LNode
{	ElemType data;
	struct LNode *next;//指向后继节点
}LinkListl

1、头插法建表

void CreateListF(LinkList *&L,ElemType a[],int n)
{	LinkList *s;
	int i
	L-(LinkList *)malloc(sizeof(LinkList));
	L->next=NULL;
	for(i=0;i<n;i++)
	{	s=(LinkList *)malloc(sizeof(LinkList));
		s->data=a[i];
		s->next=L->next;
		L->next=s;
	}

2、尾插法建表

void CreateListR(LinkList *&L,ElemType a[],int n)
{	LinkList *s,*r;
	int i;
	L=(LinkList *)malloc(sizeof(LinkList));
	r=L;
	for(i=0;i<n;i++)
	{
		s=(LinkList *)malloc(sizeof(LinkList));
		s->data=a[i];
		r->next=s;
		r=s;
	}
	r->next=NULL;
}

3、初始化线性表InitList（L）

void InitList(LinkList *&L)
{
L==(LinkList *)malloc(sizeof(LinkList));
L->next=NULL;
}

4、销毁线性表DestroyList(L)

void DestroyList(LinkList *&L)
{
LinkList *pre=L,*p=L->next;
while(p!=NULL)
{
	free(pre);
	pre=p;p=pre->next;
}
free(pre);
}

5、判断线性表是否为空表ListEmpty(L)

bool ListEmpty(LinkList *L)
{
	return(L->next==NUll)
}

6、求线性表长度ListLength（L）

int ListLength(LinkList *L)
{
    int n=0;
    LinkList *p=L;
    while(p->next!=NULL)
    {	n++;
    	p=p->next;
    }
    return n;
}

7、输出线性表DispList（L）

void DispList(LinkList *L)
{	LinkList *p=L->next;
while(p!=NULL)
{	printf("%d ",p->data;
	p=p->next;
}
printf("\n");
}

8、求线性表L中位置i的数据元素GetElem（L,i,&e)

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

9、按元素值查找LocateElem（L，e）

int LocateElem(LinkList *L,ElemType e)
{	int i=1;
	LinkList *p=L->next;
	while(p!=NULL&&p->data!=e)
	{
	p=p->next;
	i++;
	}
	if(p==NULL) return 0;
	else return i;
}

10、插入数据元素LinkList(&L,i,e)

bool LinkInsert(LinkList *&L,int i,ElemType e)
{	int j=0;
	LinkList *p=L,*s;
	while(j<i-1&&p!=NULL)
	{	j++;
		p=p->next;
	}
	if(p==NULL)
	return false;
	else
	{
		s=(LinkList *)malloc(sizeof(LinkList));
		s->data=e;
		s->next=p->next;
		p->next=s;
		return true;
	}
}

11、删除数据元素ListDelete(&L,i,&e)

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

单链表算法设计

例1：假设有一个带头节点的单链表L={a1,a2,…,an}.设计一个算法将所有节点逆置。

void Reverse(LinkList *&L)
{
	LinkList *p=L->next,*q;
	L->next=NULL;
	while(p!=NULL)
	{	q=p->next;
		p->next=L->next;
		L->next=p;
		p=q;
	}
}

双链表

双链表：每个物理节点增加一个指向后继节点的指针域和一个指向前趋节点的指针域。
优点：从任一节点出发可以快速找到其前驱节点和后继节点；
从任一节点出发可以访问其他节点。
节点类型如下：

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

增加节点

s->next=p->next;
p->next->prior-s;
s->prior=p;
p->next=s;//增加节点语句演示

删除节点

p->next->next->prior=p;
p->next=p->next->next;//删除节点语句演示

建立双链表：
1、头插法

void CreateListF(DLinkList *&L,ElemType a[],int n)
{	DLinkList *s,int i;
	L=(DLinkList *)malloc(sizeof(DLinkList));
	L->prior=L->next=NULL;
	for(i=0;i<n;i++)
	{	s=(DLinkList *)malloc(sizeof(DLinkList));
		s->data=a[i];
		s->next=L->next;
		if(L->next!=NULL);
		    L->next->prior=s;
		L->next=s;
		s->prior=L;
		}
}

2、尾插法

void CreateListR(DLinkList *&L,ElemType a[],int n)
{	DLinkList *s,*r;
	int i;
	L=(DLinkList *)malloc(sizeof(DLinkList));
	r=L;//r始终指向尾结点，开始时指向头节点
	for(i=0;i<n;i++)
	{	s=(DLinkList *)malloc(sizeof(DLinkList));
		s->data=a[i];
		r->next=s;s->prior=r;
		r=s;
	}
	r->next=NULL;
}

3、双链表插入算法ListInsert（L,i,e）

bool ListInsert(DLinkList *&L,int i,ElemType e)
{	int j=0;
	DLinkList *p=L,*s;//p指向头节点
	while(j<i-1&&p!=NULL)
	{	j++;
		p=p->next;
	}
	if(p==NULL)
	return false;
	else
	{	
		s=(DLinkList *)malloc(sizeof(DLinkList));
		s->data=e;
		s->next=p->next;
		if(p->next!=NULL)//若存在后继节点，修改其前驱指针
		p->next->prior=s;
		s->prior=p;    p->next=s;
		return true;
	}
}

4、双链表删除节点ListDelete（L,i,e）

bool ListDelete(DLinkList *&L,int i,ElemType e)
{	int j=0;
	DLinkList *p=L,*s;//p指向头节点
	while(j<i-1&&p!=NULL)
	{	j++;
		p=p->next;
	}
	if(p==NULL)
	return false;
	else
	{	q=p->next;//q指向第i个节点
		if(q==NULL)
			return false;
		e=q->data;
		p->next=q->next;
		if(p->next!=NULL)
			p->next->prior=p;
		free(q);
		return true;
    }
}

5、有一个带头节点的双链表L，设计一个算法将其元素逆置。
算法设计思路：采用头插法建表。

void Reverse(DLinkList *&L)
{	DLinkList *p=L->next,*q;//p指向开头节点
	L->next=NULL;
	while(p!=NULL)
	{
		q=p->next;
		p->next=L->next;
		if(L->next!=NULL)
			L->next->prior=p;
		L->next=p;
		p->prior=L;
	}
}

循环链表

1、循环单链表：将表中尾结点的指针域改为指向表头节点，整个链表形成一个环。由此表中任一节点出发均可找到链表中其他节点。
节点类型与非循环单链表相同。

循环双链表：形成两个环。
节点类型与非循环双链表相同。

2、与非循环单链表相比，循环单链表：
链表中没有空指针域
p所指节点为尾节点的条件：p->next==L

与非循环双链表相比，循环双链表：
链表中没有空指针域
p所指节点为尾结点的条件：p->next==L
一步操作即L->prior可以找到尾结点

有序表

概念：所有元素以递增或递减形式有序排列
1、以顺序表存储
ListInsert函数仅需两个参数L，e//对比线性表

void ListInsert(SqList *&L,ElemType e(
{	int i=0,j;
	while(i<L->length&&L->data[i]<e)
		i++;
	for(j=ListLength(L);j>i;j--)
		L->data[j]=L->data[j-1];
	L->data[i]=e;
	L->length++;//有序顺序表长度增一

2、以链表存储

void ListInsert(LinkList *&L,ElemType e)
{	LinkList *pre=L,*p;
	while(pre->next!=NULL&&pre->next->data<e)
		pre=pre->next;
	p=(LinkList *)malloc(sizeof(LinkList));
	p->data=e;
	p->next=pre->next;
	pre->next=p;
}

3、顺序表二路归并

void UnionList(SqList *LA,SqList *LB,SqList *&LC)
{	int i=0,j=0,k=0;
	LC=(SqList *)malloc(sizeof(SqList));
	while(i<LA->length&&j<LB->length)
	{	if(LA->data[i]<LB->data[j])
		{	LC->data[k]=LA->data[i];
			i++;k++:
		}
		else
		{	LC->data[k]=LB->data[j];
			j++;k++;
		}
}
while(i<LA->length)
{	LC->data[k]=LA->data[i];
	i++;k++;
}
while(j<LB->length)
{	LC->data[k]=LB->data[j];
	j++;k++;
}
LC->length=k;
}

本算法时间复杂度为O（m+n），空间复杂度为O（m+n）
//单链表写法自悟

lhl-nine
关注
专栏目录
结构体Sqlist L与Sqlist &L的区别
weixin_43624310的博客
10-31 8141
结构体Sqlist L与Sqlist &L的区别 Sqlist &L只可用于c++中；其中&表示引用的意思，而在C中&只表示取址，因此C++中下列顺序表插入函数中的L实际就是原结构体 1.证明Sqlist &L就是k: bool ListInsert(SeqList &L,int i,ElemType e){ if(i<1||i>L.length+1) return false; if(L.length>=L.MaxSize) r
数据结构算法(C语言)-线性表1
qq_44804284的博客
11-16 180
C语言-数据结构-线性表（一） 代码内实现两个功能 1.array_diff()实现对数组的元素去重。 2.sgn()函数实现符号区分。 #include <stdlib.h> #include <stdio.h> //定义一个顺序表 typedef int DataType; #define ListSize 100 typedef struct { DataType items[ListSize]; int length; } orderList; //初始
顺序存储线性表实现
少说，多做。
10-08 4393
在计算机中用一组地址连续的存储单元依次存储线性表的各个数据元素,称作线性表的顺序存储结构。   顺序存储结构的主要优点是节省存储空间，因为分配给数据的存储单元全用存放结点的数据（不考虑c/c++语言中数组需指定大小的情况），结点之间的逻辑关系没有占用额外的存储空间。采用这种方法时，可实现对结点的随机存取，即每一个结点对应一个序号，由该序号可以直接计算出来结点的存储地址。但顺序存储方法的主要缺点...
学习记录：第二章 线性表的顺序存储_顺序表_插入删除查找三种基本操作（代码、图示、C++）
weixin_45790081的博客
05-03 3979
文章目录前言一、顺序表的插入操作二、顺序表的删除操作三、顺序表的查找操作1. 按位查找2. 按值查找总结（需要注意） 前言 本文给出了顺序表的插入、删除、查找（按位、按值查找）三种基本操作的代码及相应图示助于理解，代码实现使用的是C语言在线工具。无概念解释，初学者建议配合书本食用。 【如果图片看不清楚，网页版是很清晰的。😦】 一、顺序表的插入操作 #include <stdio.h> #define MaxSize 10 typedef struct{ int data[MaxSize];
线性表的操作
ZJ_Chen686的博客
12-02 453
void EmptyList(List *L) { L->length=0; }  //线性表的清空即将表长度置为零。 //判空即判断顺序表长度是否为0。 //顺序表元素个数即L->length。 List * CreateList(int len) { List*L=(List*)malloc(sizeof(List));//申请顺序表空间  L->length=0;//初始
数据结构-线性表-PPT
02-04
"数据结构-线性表-PPT" 数据结构是一门研究非数值计算的程序设计问题的学科，它研究的是计算机存储、表示、操作和保护非数值信息的方法和技术。线性表是数据结构的一种基本结构，它是一种线性结构，只有一个首结点...
2.C-数据结构-线性表-线性表源码
最新发布
09-07
2.C-数据结构-线性表-线性表源码
2.C-数据结构-线性表-链表源码
09-07
2.C-数据结构-线性表-顺序表源码
2.C-数据结构-线性表-顺序表源码
08-30
2.C-数据结构-线性表-顺序表源码
数据结构-线性表的链式存储
09-17
线性表是计算机科学中一种基础且重要的数据结构，它由有限个相同类型元素组成，按照线性顺序排列。在实际应用中，线性表的数据元素可以是数字、字符串、对象等各种类型。线性表的链式存储是数据结构课程中的核心概念...
顺序表基本运算的实现（第二章：线性表）
weixin_44630560的博客
07-26 1297
顺序表基本运算的实现 基本运算—初始化线性表InitList(L) ① 需求 构造一个空的线性表L ② 方法 分配空间，并将length成员设置为0 ③ 算法 void InitList(SqList *&L) //指针的引用 { L=(SqList *)malloc(sizeof(SqList)); L->length=0; } SqList的结构体 #define MaxSize 50 typedef struct { ElemType data[MaxSize]; in
c语言L->length与L.length
ljishuboke的博客
03-04 8139
C语言中， -> 是指针操作符， 点是结构操作符。如果 L 是一个结构实例的指针，要用 -> 访问结构里的变量，而不能用点。如果L 是一个结构的实例而非指针，只能用点而不能用 -> 。L—>length++与++(L.length)区别在于自增发生在使用前还是使用后，比如 L->length等于5，a=L->length++,则a=5， L->length自增为6；而b=++(L.length)，则
单链表操作实现getelem_线性表的实现和操作
weixin_28864057的博客
12-29 2467
1.顺序表(顺序存储)对于非空的线性表和线性结构，有以下特点:1.存在唯一的一个被称作”第一个“的数据元素2.存在唯一一个被称作”最后一个“的数据元素3.除了第一个之外，结构中的每个数据元素均有一个前驱4.除了最后一个之外，结构中的每个数据元素都有一个后继。顺序链表的实现:0.定义最大长度#define MAXSIZE 100 #define OK 1 #define ERROR 0创建表结构//...
数据结构：顺序表的基本操作
热门推荐
Keep Fighting All The Time
05-03 10万+
线性表的顺序存储 顺序表的线性存储示意图 C语言定义线性表的顺序存储结构 线性表的顺序存储        线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表在逻辑结构上相邻的元素存储在连续的物理存储单元中，即：通过数据元素物理存储的连续性来反应元素之间逻辑上的相邻关系。采用顺序存储结构存储的线性表通常简称为顺序表。        顺序存
数据结构篇——顺序表
handsomeRE的博客
06-16 810
数据结构篇——顺序表
线性表－顺序存储结构
Ddreaming的博客
08-23 1062
线性表－顺序存储结构 下面是用c语言实现的线性表，顺序存储结构，是用一维数组实现的，即把第一个数据元素存到数组下标为0的位置中，接着把线性表相邻的元素存储在数组相邻的位置。这种顺序存储方式优点是可以快速的存取表中任一位置的元素，但是插入和删除需要移动大量元素，当线性表变化较大时，难以确定存储空间的容量，因为这种存储方式需要提前确定数组的长度，下面的MAXSIZE就是提前指定的数组
2.1线性表的基本操作（数据结构C语言版）
weixin_51575278的博客
07-15 6285
1、InitLISt(&L) 操作结果:构造一个空的线性表L int initLISt(SqList *L) { L->length=0; return 1; } 2、printLIst(L) 操作结果：打印一个顺序表，方便测试操作是否正确 int printList(SqList L) { if(L.length==0) { printf("链表为空\n"); return 0; } int i; for...
第三周【项目1 - 顺序表的基本运算】
ljj19971222的博客
09-20 287
/*   *Copyright (c)2017,烟台大学计算机与控制工程学院   *All rights reserved.   *文件名称：   *作    者：李佳骏  *完成日期：2017年9月20日   *版 本 号：v1.0   *问题描述：实现有关线性表的各种运算     *输入描述：函数输入 *程序输出：函数输出 */   问题及代码： 目的是要测试
数据结构之线性表
hzhandsome的专栏
06-22 380
一、线性表 线性表是一个由N个数据元素组成的有限序列。其中一个数据元素可以由若干个数据项组成。常把数据元素称为记录，含有大量记录的线性表称为文件。 1 、线性表的顺序存储结构表示与实现：   typedef struct SqList { ElemType *elem;int length;int listsize; }SqList;     线性表的基本操作： 1. 构造一
数据结构-线性表详解
"沈阳工程学院信息工程系的数据结构课件，主要涵盖了线性表的概念、表示及实现" 在计算机科学中，数据结构是组织和管理数据的重要工具，它研究如何高效地存储、检索和操作数据。线性表是数据结构中最基础也是最常用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值