数据结构之线性表(附代码)

数据结构 之 线性表(附代码)

线性表思维导图:

在这里插入图片描述

线性表定义(逻辑结构):

线性表L是具有相同数据结构类型的n个数据元素的有限序列
L=(a1,a2,a3,a4,…,ai,…,an)

: 1. 元素个数有限
   2. 逻辑上有先后顺序性,有先后次序
   3. 都是数据元素,数据类型相同,占空间相同
   4. 除a1外,都有唯一前驱; 除an外,都有唯一后继

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

#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);
}
运行结果:110241

#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);
}
运行结果:110241024

一、顺序表

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
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值