数据结构：1.线性表、栈和队列的存储结构

当谈及一个数据结构时候，应该考虑它的逻辑结构、物理结构以及数据的运算

---

前言

1.线性表，全名为线性存储结构（对应的非线性存储结构有树、图），线性表存储数据可以分为以下两种：

• 顺序存储结构：顺序表的特点就是存储空间连续分配，可以静态分配也可以动态分配。
• 链式存储结构：链式存储结构的特点是存储空间可以不连续也可以连续，链式存储结构可以分为单链表、双链表、循环链表和静态链表。

2.栈和队列其实也是特殊的线性表，它们在逻辑上来说都是顺序存储的，物理存储可以静态分配也可以动态分配；唯一的区别就是运算的不同，普通的线性表增删改查可以操作在任意地方，但是栈和队列不行，栈的插入、删除和查看只能在栈头进行（先进后出）；队列的插入在队尾进行，删除在对头进行（先进先出）。

栈可以分为：

• 顺序栈：顺序栈底层采用的是数组。
• 链栈：链栈底层采用的是链表。

---

1.线性表

1.1 顺序表

顺序表实际就是数组结构体。

1.1.1顺序表的静态分配：数组大小分配是固定的。

#define maxsize 100;
typedef int ElemType;
typedef struct{
	ElemType data[maxsize];
	int length;
}SSeqList;

1.1.2顺序表的动态分配：通过malloc分配连续的一段存储空间。

#define initsize 10;
typedef int ElemType;
typedef struct{
	ElemType *data;
	int maxsieze;  //记录动态分配的大小
	int length;	   //当前存放数据的大小
}DSeqList;

1.2 链表

1.2.1单链表：最后一个Node的next指向NULL

typedef int ElemType;
typedef struct LNode{
	ElemType data;
	struct LNode* next; // 定义指向下一个Node的指针
}LNode;

单链表的插入和删除(带头结点和不带头结点有所不一样)解决方案就是，找到要插入或者删除的位置的前一个节点 j

1.插入
1.1 不带头结点

bool InsertNode(LinkNode& L, ElemType e, int i)
{
	if(i<1)
		return false;
	
	//不带头结点的插入和删除，对于第一个节点都需要单独处理。
	if(i==1)
	{
		LinkNode* Q = (LinkNode*)malloc(sizeof(LinkNode));
		Q->data = e;
		Q->next = L;
		L = Q;
		return true;
	}

	int j=1;
	LinkNode* p = L;
	while(j<i-1 && p!=NULL)
	{
		p = L.next;
		j++;
	}
	if(p==NULL)
		return false;
		
	LinkNode* Q = (LinkNode*)malloc(sizeof(LinkNode));
	Q->data = e;
	Q->next = p->next;
	p->next = Q;
	
	return true;
}

1.2 带头结点

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

2.删除
2.1不带头结点

bool deleteNode(LinkNode* L, int i, ElemType& e)
{
	if(i<1)
		return false;
	//如果要删除第一个节点，要做特殊处理，因为他前面没有头结点了
	if(i == 1)
	{
		LinkNode* s = L;
		L = s->next;
		e = s->data;
		
		free(s);
		return true;
	}
	
	LinkNode* p;
	int j=1;
	p = L;
	while(p!=NULL && j<i-1)
	{
		p=p->next;
		j++;
	}
	if(p==NULL || p->next==NULL)
		return false;
		
	LinkNode* s = L;
	L = s->next;
	e = s->data;
	
	free(s);
	return true;
}

2.2带头节点

bool deleteNode(LinkNode* L, int i, ElemType& e)
{
	if(i<1)
		return false;
		
	LinkNode* p;
	int j;
	p = L;
	
	while(p!=NULL && j<i-1)
	{
		p = p->next;
		j++;
	}
	
	if(p==NULL || p->next ==NULL)
	{
		return false;
	}
	
	LinkNode* s = p->next;
	e = s->data;
	p->next = s->next;
	free(s)
	return true;
	
}

1.2.2双链表：第一个Node的prior和最后一个Node的next指向NULL

typedef int ElemType;
typedef struct LNode{
	ElemType data;
	struct LNode* prior; // 定义指向上一个Node的指针
	struct LNode* next; // 定义指向下一个Node的指针
}LNode;

1.2.3循环链表：所有Node的prior和next都不为NULL

typedef int ElemType;
typedef struct LNode{
	ElemType data;
	struct LNode* prior; // 定义指向上一个Node的指针
	struct LNode* next; // 定义指向下一个Node的指针
}LNode;

1.2.4静态链表：空间连续，存储不一定连续

容量固定不可变（操作系统的文件分配表FAT中会用到）

#define maxsize 10   //静态链表的最大长度
struct Node{         //静态链表结构类型的定义
	ElemType data;   //存储数据元素
	int next;        //下一个元素的数组下标
};

void testSLinkList()
{
	struct Node a[maxsize];
	//...后续代码
}

或者可以如下定义：

#define maxsize 10
typedef struct{
	ElemType data;
	int next;
}SlinkList[maxsize];

2.栈

2.1顺序栈

#define maxsize 10;
typedef struct{
	ElemType data[maxsize];
	int top；         //栈顶指针，初始化为-1
}lineStack; 

2.2 链栈

链栈的定义实际上就是单链表，该单链表一般没有头结点，如果栈空，头指针为NULL。

#define maxsize 10;
typedef struct lineStack{
	ElemType data;
	struct lineStack * next;
}linkStack; 

3.队列

3.1 顺序队列

#define maxsize 10;
typedef struct{
	ElemType data[maxsize];
	int front;              //头指针，用于出队 两个指针的操作都是(front+1)%maxsize
	int rear;               //尾指针，用于入队
	
}LineQueue;

3.2 链式队列

---

总结