数据结构之线性表（附代码）

最新推荐文章于 2023-03-12 14:35:41 发布

千寻瀑༄

最新推荐文章于 2023-03-12 14:35:41 发布

阅读量1w

点赞数 48

分类专栏： # 表

本文链接：https://blog.csdn.net/qq_41587740/article/details/104112315

版权

表专栏收录该内容

1 篇文章 8 订阅

订阅专栏

数据结构之线性表（附代码）

线性表思维导图:
线性表定义（逻辑结构）：

线性表思维导图:

在这里插入图片描述

线性表定义（逻辑结构）：

线性表L是具有相同数据结构类型的n个数据元素的有限序列
L=(a₁,a₂,a₃,a₄,…,a_i,…,a_n)

注： 1. 元素个数有限
　　 2. 逻辑上有先后顺序性，有先后次序
　　 3. 都是数据元素，数据类型相同，占空间相同
　　 4. 除a₁外，都有唯一前驱；除a_n外，都有唯一后继

注：&表示对修改的结果“带回来”，即操作同一地址空间的数据，例：

#include<stdio.h>

void test(int x){
	x = 1024;
	printf("test内部x=%d\n",x);
}

int main(){
	int x = 1;
	printf("执行test前x=%d\n",x);
	test(x);
	printf("执行test后x=%d\n",x);
}
运行结果：1，1024，1

#include<stdio.h>

void test(int &x){
	x = 1024;
	printf("test内部x=%d\n",x);
}

int main(){
	int x = 1;
	printf("执行test前x=%d\n",x);
	test(x);
	printf("执行test后x=%d\n",x);
}
运行结果：1，1024，1024

一、顺序表

1、顺序表思维导图:

在这里插入图片描述

2、顺序表的逻辑结构：

   逻辑相邻物理也相邻

3、顺序表基本操作的功能实现：

1.线性表的静态定义：

#define MaxSize 100;			//定义顺序表最大长度
typedef struct{
	ElemType data[MaxSize];		
	int length;					//当前顺序表的长度
}SqlList;						//顺序表的类型定义

2.线性表的动态定义：

typedef struct{
	int *data;					//动态分配数组的指针	
	int MaxSize;				//顺序表的最大容量
	int length;					//当前顺序表的长度
}SqlList;						//顺序表的类型定义

3. 线性表的静态初始化：

void InitList(SqlList &L){
	for(int i = 0;i < MaxSize; i++)
		L.data[i] = 0;			//防止“脏数据”
	L.length = 0;
}

4. 线性表的动态初始化：

#define InitSize 10
void InitList(SqlList &L){
	L.data = (int *)malloc(InitSize * sizeof(int))
	L.length = 0;
	L.MaxSize = InitSize;
}

5. 线性表的插入：

bool ListInsert(SqlList &L,int i,ElemType e){
	if(i < 1 || i > L.length)		//判断i值是否合法
		return false;
	if(L.length > L.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;
}

6. 线性表的删除：

bool ListDelete(SqlList &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 true;
}

7. 线性表的按位查找：

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

8. 线性表的按值查找：

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

9.动态增长内存：

void IncreaseSize(SqlList &L,int len){
	int *p = L.data;
	L.data = (int *)malloc((L.MaxSize+len) * sizeof(int));
	for(int i = 0;i < L.length;i++)
		L.data[i] = p[i];
	L.MaxSize = L.MaxSize + len;
	free(p);
}

二、链表：

1. 链表的思维导图：

在这里插入图片描述

2.链表的逻辑结构：

逻辑上相邻物理上不一定相邻，由指针指向下一个数据元素

3. 单链表：

注：未明确说明，一律按带头节点处理
注： LNode * = LinkList,但是LinkList强调的是一个链表，而LNode *强　　　　调的是一个节点。例如:
声明一个单链表时：

LinkList L;

定义一个节点时：

LNode *p;

1.单链表的定义：

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

2.不带头节点的单链表的初始化：

bool InitList(LinkList &L){
	L = NULL;				//空表 
	return true;
}

3.带头结点的单链表的初始化：

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

4.指定节点的后插操作：

bool InsertNextNode(LNode *p,int e){
	if(p == NULL)
		return false;
	LNode *s = (LNode *)malloc(sizeof(LNode));
	if(s == NULL)
		return false;
	s->data = e;
	s->next = p->next;
	return true;
}

5.带头结点的按位序插入：

bool ListInsert(LinkList &L,int i,int e){
	if(i < 1)
		return false;
	LNode *p;
	int j = 0;
	p = L;
	while(p != NULL && j < i-1){		//找要插入位置节点的前驱节点 
		p = p->next;
		j++;
	} 
	InsertNextNode(p,e);				//后插操作 
}

6.不带头结点的按位序插入：

bool ListInsert(LinkList &L,int i,int e){
	if(i < 1)
		return false;
	if(i == 1){
		LNode *s = (LNode *)malloc(sizeof(LNode));
		s->data = e;
		s->next = L;
		return true;
	}
	LNode *p;
	int j = 0;
	p = L;
	while(p != NULL && j < i-1){		//找要插入位置节点的前驱节点 
		p = p->next;
		j++;
	} 
	InsertNextNode(p,e);				//后插操作 
}

7.指定节点的前插操作：

bool InsertPriorNode(LNode *p,LNode *s){
	//第一种方法：遍历整个单链表，找到p节点的前驱节点，执行后插操作
	//第二种方法：在p节点后直接插入新节点q，然后交换 p节点和q节点的值
	//此处只演示第二种方法
	if(p == NULL || s == NULL)
		return false;
	s->next = p->next;
	p->next = s;
	int temp = p->data;
	p->data = s->data;
	s->data = temp;
	return true;
}

8.带头节点的按位序删除：

bool ListDelete(LinkList &L,int i,int &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; 
}

9.指定节点的删除：

bool DeleteNode(LNode *p){
	if(p == NULL)
		return false;
	LNode *q = p->next;
	p->data = p->next->data;
	p->next - q->next;
	free(q);
	return true;
}

10.带头结点的按位查找：

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

11.带头结点的按值查找：

LNode* locateElem(LinkList L,int e){
	LNode *p = L->next;
	while(p != NULL && p->data != e)
		p = p->next;
	return p;
}

12.求表的长度：

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

13.带头结点的判断空表：

bool Empty(LinkList L){
	if(L->next == NULL)
		return true;
	else
		return false;
}

14.尾插法建立单链表：

LinkList List_TailInsert(LinkList &L){
	int x;
	L = (LinkList)malloc(sizeof(LNode));
	LNode *s,*r = L;
	scanf("%d",&x);
	while(x != 9999){
		s = (LNode *)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf("%d",&x);
	}
	r->next = NULL;
	return L;
}

15.头插法建立单链表：

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

4.双链表：

1.双链表的定义：

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

2. 双链表的初始化：

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

3.双链表的后插操作：

bool InsertNextDNode(DNode *p,DNode *s){
	if(p==NULL || s == NULL)
		return false;
	s->next = p->next;
	if(p->next != NULL)				//p节点有后记节点 
		p->next->prior = s;
	s->prior = p;
	p->next = s;
	return true;
}

4.双链表的节点删除：

bool DeleteNextDNode(DNode *p){
	if(p == NULL)
		return false;
	DNode *q = p->next;
	if(q == NULL)
		return false;
	p->next = q->next;
	if(q->next != NULL)
		q->next->prior = p;
	free(q);
	return true;
}

5.双链表的销毁：

 void DestoryList(DLinkList &L){
 	while(L->next != NULL)
 		DeleteNextDNode(L);
 	free(L);
 	L = NULL;
 }

6.双链表的前向遍历：

void PriorTraverse(DNode *p){
	while(p != NULL){
		printf("%d\n",p->data);
		p = p->prior;
	}
}

7.双链表的后向遍历：

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

5.循环单链表：

把单链表的最后一个指针指向头节点L即可。其他操作同单链表相似，小编就水了哈。
注：当执行插入操作时，可将L指向最后一个节点。这样就不用遍历整　　　个链表了，神奇不神奇。

6.循环双链表

1.循环双链表的定义：

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

2.循环双链表的初始化：

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

3.循环双链表的判空：

bool Empty(DLinkList L){
	if(L->next == L)
		return true;
	else
		return false;
}

4.判断节点P是否为循环双链表的表尾节点：

bool isTail(DLinkList L,DNode *p){
	if(p->next == L)
		return true;
	else
		return false;
}

5.循环双链表的插入：

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

6.循环双链表的删除：

bool DeleteNextDNode(DNode *p){
	if(p == NULL)
		return false;
	DNode *q = p->next;
	if(q == NULL)
		return false;
	p->next = q->next;
	q->next->prior = p;
	free(q);
	return true;
}

7.静态链表：

1.什么是静态链表：

特殊类型的单链表，分配一片连续的存储空间，各个节点集中安置，单链表的指针映射成游标，即用数组的方式实现链表。如图：
在这里插入图片描述
注：假设第一个数据元素的地址为addr，一个数据元素4B，一个游标4B，则第n个数据元素的地址：(addr + n * 8)B

2. 静态单链表的定义：

typedef struct Node SLinkList[MaxSize]；

 typedef struct Node{
	int data;			//存储数据元素 
	int next;			//存储数据元素的数组下标 
}SLinkList[MaxSize];

void test(){
	SLinkList a;		//初始化了一个MaxSize大小的数组
}

或者

struct Node{
	int data;			//存储数据元素 
	int next;			//存储数据元素的数组下标 
};

typedef struct Node SLinkList[MaxSize]；

二者等价

3.静态链表的特点：

优点：增删不需要移动大量的元素
缺点：不能随机存取，查找不便；容量固定不可变

三、顺序表和链表的对比：

1.顺序表：

1.优点：

	1.随机存取，查找速度快。
	2.存储密度高，每个数据元素只需要存储数据本身即可

2.缺点：

    1.空间分配不便，需要一块连续的存储空间
    2.改变容量不便

2.链表：

1.优点：

    1.空间分配方便，只需分配离散的小空间即可
    2.容量改变方便

2.缺点：

    1.存储密度小，除了要存储数据本身外，还要存储指针
    2.不可随机存取，查找不便

在这里插入图片描述 开放式答题框架技巧：
ps: 累死小编了，整整敲了一天代码，有些地方直接省略掉了，大家脑补脑补哈。这是小编第一次写博客，不足之处请多多谅解。有任何问题，随时可以叨扰小编。若有错误的地方，请联系小编指正。

千寻瀑༄

关注

48
点赞
踩
265

收藏

觉得还不错? 一键收藏
4
评论
数据结构之线性表（附代码）

白话+图解数据结构之线性表线性表思维导图:线性表定义（逻辑结构）：线性表的基本操作原型（严蔚敏版）：顺序表1、顺序表思维导图:2.顺序表的逻辑结构：3、顺序表基本操作的功能实现：1.线性表的静态定义：2.线性表的动态定义：3. 线性表的静态初始化：4. 线性表的动态初始化：5. 线性表的插入：6. 线性表的删除：7. 线性表的按位查找：8. 线性表的按值查找：4.顺序表的特点和优点：链表：1...
复制链接

扫一扫