数据结构（未完持续）

数据结构

一.基本概念和术语

 1.数据的分类:

• 数据：是客观事物的符号表示
• 数据元素：是数据的基本的单位
• 数据项：是组成数据元素的最小单位
• 数据对象：是性质相同的数据元素的集合，是数据的子集

 2. 数据的结构

• 逻辑结构
  • 线性结构
  • 非线性结构
• 存储结构
  • 顺序存储结构（随机存取存储结构）
  • 链式存储结构（顺序存取存储结构）

 3.算法的五个特性

• 有穷性
• 确实性
• 可行性
• 输入
• 输出

 4.评价算法的四个准则

• 正确
• 可读
• 健壮
• 高效性

---

二.线性表

 1.线性表的介绍

 数据特性相同的元素构成的有限的序列称为线性表

 2.线性表分类

• 顺序表（顺序存储结构）
• 链表（链式存储结构）

 3.顺序表

 两种操作：插入、删除

插入到第i个位置操作

	if((i<1)||(i>L.length+1)) return error;
	if(L.length==MAXSIAZE) return error;
	for(j=L.length-1;j>=i-1;j--)
		L.elem[j+1]=L.elem[j];
	L.elem[i-1]=e;
	return OK;

 第一句：是用来判断i的取值是否合法
 第二句：用来判断是否存储空间是否已满
 第三句：接着是一个for循环，i位置之后的值都往后移一位
 第四句：当插入末尾时，直接执行该句
 补充：

• Length指的是存储空间中元素的个数
• MAXSIZE指的才是数组空间的长度

  这里为什么i>L.length+1的?原因如下：

  因为顺序表数据算法中，他的插入都是依次插入的，所一旦你要插入的值大于这个数组长度加一那么这肯定是不符合情况的，所以出现了这一步

删除第i个位置操作

	if((i<1)||(i>L.length)) return error;
	for(j=i;j<=L.length-1;j++)
		L.elem[j-1]=L.elem[j];//依次往前提一位
	--L.length;//数组的长度跟着减一位
	return OK;

 4.链表

 链表包含两个域，数据域和指针域，指针域中存储的信息即为指针。
 注意

• 首元结点：第一个数据元素的结点
• 头指针：指向链表中第一个结点的指针
• 头结点：首元结点之前附设的结点

一个指针域可以没有头结点但是必须有头指针和首元结点；链表也是有前驱和后继的。
 操作实现：插入、删除

插入第i个位置

	S=new LNode;//设置插入的新结点
	p=L;j=0;
	while(p && j<i-1){
		p=p->next;
		j++;
	}
	if(!p || j>i-1) return error;
//主要判别两种情况，要么是p到达最后一位或者i本身就小于0
	s->next=p->next;
	p->next=s;
	s->data=e;
	return OK;

在链接的过程中，一定要保证先连后断的原则。

删除第i个位置

	p=L;
	d=p->next;
//目的在于最后一步能完整的释放p->next结点所占的空间
	p->next=d->next;
	delete q;//删除q释放空间。

  4.1 循环链表

  以往单链表他的尾结点的指针域为空，所以此时我们将尾结点的指针域指向头节点，从而形成了一个循环链表。

  4.2 双向链表

 双向链表的操作：插入和删除

插入第i个位置

	p=L->next;
	j=0;
	while(p && j<=i)
	{
		p=p->next;
		j++;
	}
	if(i<1 || !p) return error;
	s=new LNode;
	s->prior=p->prior;
	p->prior->next=s;
	s->next=p;
	p->prior=s;

  这里一定要明白：凡是插入都是插在其前面的，也就是说：插入到第5个位置，实际上实在第五个位置前面插的。

第i个位置删除操作

	p=L->next;
	j=0;
	while(p && j<=i)
	{
		p=p->next;
		j++;
	}
	if(i<1 || !p) return error;
	p->next->prior=p->prior;
	p->prior->next=p->next;
	delete p;

总结;

  顺序表和链表的比较：

• 空间
  • 顺序表的空间是一开始就分配好的
  • 链表的空间不需要预先分配
• 时间性能
  • 顺序表是由数组实现的，是一种随机存取结构，即只需要知道第一个位置，那便知道之后的位置。
  • 链表是一种顺序存取，只能依靠前面的指针来指向，即如果想访问第i个位置，必须从头找到i的位置。
• 效率
  • 顺序表便于取值，但不便于插入与删除；
  • 链表便于插入与删除，但不便于取值；

   补充：

• 不管是顺序表还是链表都属于线性表。那么线性表有的属性，这两个都有，比如：前驱和后继，前驱和后继都是结点；
• 顺序表的位置和索引是不一样的，就把它当做数组来记忆就好。链表没有索引，只有位置。
• 一般在里面涉及到的插入第i个位置都是指的前面的地方

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-91WEERTE-1602991381775)(/storage/emulated/0/Pictures/Screenshots/one.jpg)]

三.栈和队列

 1.栈

 栈是限定仅在表位进行插入和删除操作的线性表，表尾端称为栈顶，表头端称为栈底。其实本章是相较于第二章的一种延伸说明。依靠于第二章的顺序存储结构和链表存储结构所实际的一种储存方式。

 1.1 栈的读取方式:

 是一种先进后出的存储方式。

 1.2 栈的操作：

 栈一般分为两种，一种为顺序栈一种为链栈

 1.2.1 顺序栈：

 顺序栈即以顺序存储结构存储的

 顺序栈的特点：
	1. 有前驱有后继（因为栈还是线性表）
	2. 是随机存取的结构（因为顺序存储结构的性质）
	3. 有头指针和尾指针，但中间没有指针（top和base表示）
- - - - - - - - - - - - - - - - - - - - - - - - - 
 顺序栈和顺序表的区别:  
   	虽然两个都为顺序存储，但是一定要区分开来，顺序表是顺序结构的初阶方式，顺序栈则是顺序存储的高阶方式，具体看如下：
	1. 顺序表是依靠索引值的，顺序栈则依靠于头尾指针的
	2. 顺序表任意位置都可操作，但是顺序栈只能在栈顶进行操作

顺序栈的入栈

• 操作图如下：
  t=top（栈顶；表尾处）；b=base（栈底，表头处）;

空栈

指针	栈表
t,b

入栈

指针	栈表
t
b	A

这里我们要注意这个top指针永远指向较高一位

• 具体代码如下：

  首先初始化;
	S.base=new SElemType(MAXSIZE)
	//分配一个MAXSIZE大小的空间
	if(!S.base) exit(OVERFLOW);//存储空间分配失败
	S.top=S.base;//空栈
	S.stacksize=MAXSIZE;//替换MAISIZE便于之后的运算
	return ok；

入栈操作（插入元素e作为新的栈顶）:

	if(S.top-S.base=S.stacksize) return error;
	*S.top++=e;
	return ok

 a++=2;代表着a先加2，再加1;++a，代表着先加在用

出栈操作

	if(S.top==S.base) return error;
	e=*--S.top;
	return ok;

 1.2.2 链栈

 链栈指的是采用链式存储的栈

 链栈的特点：
	1. 有前驱有后继
	2. 有数据域和指针域
	3. 必须有头指针,且只有头指针
 链栈和单链表的区别;
   	其实他们的区别不大，见以下几点：
	1. 链栈只能在栈顶进行操作，单链表不要求
	2. 单链表为了方便操作才加个头结点，且不用用来存放数据
	3. 而链栈不需要头节点，直接通过指针指向栈顶元素即可

 补充说明：
 单链表中，链表增加头结点的作用：

• 便于头结点的处理：

	增加了头结点后，首元结点的地址就保存到头结点的指针域中，则对链表的第一个数据元素的操作与其他数据元素相同，无需进行特殊处理

• 便于空表和非空表的统一处理

	当链表不设头结点时，假设L为单链表的头指针，它应该指向首元结点，那么此时只能通过L指针来进行判断空表的操作L==null，判断非空表时，则L->next!=null;两种操作
	当链表设置头结点，即判断是否为空表，只需要判断L->next是否等于空即可

 链栈中：

	由于栈的特性，入栈和出栈都是在栈顶进行的，因此我们只需要直接对栈顶进行操作即可。
# 	你也可以直接和顺序栈表产生关联，顺序栈表中，top永远指向稍前一位，这无疑就是默认在栈中产生了一个头结点
 	就是这样的。	

入栈操作

	p=new StackNode;
	p->data=e;
	p->next=S;
	

出栈操作

	e=S->data;
	p=S;//完美释放栈顶元素空间
	S=S->next;
	delete p;

 2.队列

 和栈相反，队列是一种先进先出的线性表，它只允许在表的一端进行插入，而在另一端删除元素。在队列中，允许插入的一端称为队尾，允许删除的一端则称为队头。

 2.1 队列的读取方式

 队列是一种先进先出的存储方式

 2.2 队列的操作

 队列主要指循环队列一般分为顺序表示和链队表示

 2.2.1 循环队列的顺序表示

 注意一下区别：

 顺序存储队列的特点：
	1. 队尾（rear）插入，队头（front）删除
	2. 其实rear和front不能称为指针，只不过是一种索引
	3. rea和front初始值都是0
	4. 插入时，队尾指针指向插入前的一位
	5. 删除时，队头指针指向删除的那一位
 顺序存储队列和顺序栈相比
	1. 有前驱有后继（因为栈还是线性表）
	2. 是随机存取的结构（因为顺序存储结构的性质）
	3. 有头指针和尾指针但中间没有指针（front和rear表示）
	4. 具体操作方式也是一样

循环队列的插入和删除操作

• 操作图如下：

空队

序号	指针	队表
3
2
1
0	front rear

入队

序号	指针	队列
3	rear
2		C
1		B
0	front	A

出队,A/B已删除

序号	指针	队列
3	rear
2	front	C
1
0

循环开始

序号	指针	队列
3		A
2	front	C
1
0	rear

队列有一个很大的缺点就是，由于只能在队尾进行插入，这也就导致，rear每次插入都要加1，如图：队列的长度是4，可是不断的插入这也就导致了rear不断加1，早成了一种假溢出的情况，为了改变这种情况，引入了取模操作，就是通过rear=(rear+1)%MAXSIZE;

• 代码如下

  首先初始化
	QElemType *base;
	int front;
	int rear;
	front=rear=0//初始化都为0
	Q.base=new QElemType[MAXSIZE];//分配存储空间
	if(!Q.base) exit(OVERFLOW);
	Q.front=Q.rear=0;//判断是否为空队
	return OK;

入队操作

  算出循环队列的长度
	return(Q.rear-Q.front+MAXSIZE)%MAXSIZE;
--------------------------------------------------
  (Q.rear-Q.front+MAXSIZE)%MAXSIZE看不懂的话可以进行数学变换加深理解
	rear-front+MAXSIZE = MAXSIZE-(front-rear)
	最后在通过%MAXSIZE来判断变化值

	if((Q.rear+1)%MAXSIZE==Q.front) 
		return BILL//满栈
	Q.base[Q.rear]=e;
	Q.rear=(Q.rear+1)%MAXSIZE;
	return OK;

出队操作

	if(Q.front==Q.rear) renturn error;//栈空
	e=Q.base[Q.front];
	Q.front=(Q.front+1)%MAXSIZE;
	return OK;

 2.2.2 循环队列的链队表示

链队采用链式存储结构实现的队列，通常链队用单链表来表示

• 有指针域和数据域
• 一个链队必然需要指示队头和队尾的头指针和尾指针
• 和线性表中单链表无太多差别
• 为了操作方便，也是有头结点的，栈是不需要头结点的¹

链队的操作

   初始化：
   	Q.front=Q.rear=new QNode;
   	Q.front->next=null;//头结点的指针域置为空，就是加个头结点
   	return ok;

链队的入队操作
链队只能在队尾进行插入

	p=new QNode;//设置新的结点p
	p->data=e;
	p->next=null;
	//插入p的地址就是队尾地址，所以先置为空
	Q.rear->next=p;
	Q.rear=p;

链队的出队操作

• 操作图如下：

	if(Q.front==Q.rear) return error;
	//队列为空，则返回ERROR
	e=Q.front->data;
	p=Q.front->next;
	Q.front->next=p->next
	if(Q.rear==p) Q.rear=Q.front;
	//最后一个元素被删，队尾指针指向头结点
	delete p;

---

1. 链栈 ↩︎