1.栈
1.1顺序栈
#define MAXSIZE 100 //定义栈中元素的最大个数
typedef int ElemType;
typedef struct{
ElemType data[MAXSIZE];
int top; //栈顶指针
}SqStack;
若存储栈的长度为StackSize,则栈顶位置top必须小于StackSize。当栈存在一个元素时,top等于0,因此空栈的判断条件基本为top=-1。
//栈的初始化
void InitStack(SqStack *S){
S->top = -1; //初始化栈顶指针
}
//栈是否为空
bool StackEmpty(SqStack S){
if(S.top == -1){
return true;
}else{
return false;
}
}
//进栈
//插入元素e为新的栈顶元素
Status Push(SqStack *S, ElemType e){
//满栈
if(S->top == MAXSIZE-1){
return ERROR;
}
S->top++; //栈顶指针增加一
S->data[S->top] = e; //将新插入元素赋值给栈顶空间
return chenggong;
}
//出栈
//若栈不空,则删除S的栈顶元素,用e返回其值
//ElemType *e为指针类型,以便在函数内部修改其值,并改变外部对 e 的引用。
Status Pop(SqStack *S, ElemType *e){
//栈空
if(S->top == -1){
return ERROR;
}
*e = S->data[S->top];
S->top--; //栈顶指针减一
return ;
}
1.2 共享栈
利用栈底位置相对不变的特征,可让两个顺序栈共享一个一维数组空间,将两个栈的栈底分别设置在共享空间的两端,两个栈顶向共享空间的中间延伸。
假设有两个栈。0号和1号。栈中元素最大个数为MaxSize.两个栈的栈顶指针都指向栈顶元素,top1=MaxSize 时1号栈为空,top0=-1时,0号栈为空;当top0+1=top1时,判断为栈满。
当0号栈进栈时top0先加1再赋值,1号栈进栈时top1先减一再赋值。
当0号栈出栈时top0减一,1号栈出栈时top1加一。
/*两栈共享空间结构*/
#define MAXSIZE 50 //定义栈中元素的最大个数
typedef int ElemType; //ElemType的类型根据实际情况而定,这里假定为int
/*两栈共享空间结构*/
typedef struct{
ElemType data[MAXSIZE];
int top0; //栈0栈顶指针
int top1; //栈1栈顶指针
}SqDoubleStack;
//进栈
Status Push(SqDoubleStack *S, Elemtype e, int stackNumber){
if(S->top0+1 == S->top1){ //栈满
return ERROR;
}
if(stackNumber == 0){ //栈0有元素进栈
S->data[++S->top0] = e; //若栈0则先top0+1后赋值
}else if(satckNumber == 1){ //栈1有元素进栈
S->data[--S->top1] = e; //若栈1则先top1-1后赋值
}
return success;
}
//出栈
Status Pop(SqDoubleStack *S, ElemType *e, int stackNumber){
if(stackNumber == 0){
if(S->top0 == -1){
return ERROR; //说明栈0已经是空栈,溢出
}
*e = S->data[S->top0--]; //将栈0的栈顶元素出栈,随后栈顶指针减1
}else if(stackNumber == 1){
if(S->top1 == MAXSIZE){
return ERROR; //说明栈1是空栈,溢出
}
*e = S->data[S->top1++]; //将栈1的栈顶元素出栈,随后栈顶指针加1
}
return success;
}
1.3 链式栈
不存在栈满上溢的情况,通常用单链表,且所有操作在单链表表头进行。top指向栈顶。则栈为空时,top=NULL.
//链栈
//创建结点
typedef struct StackNode{
ElemType data;
struct StackNode *next;
}StackNode, *LinkStackPrt;
//创建链栈
typedef struct LinkStack{
LinkStackPrt top;
int count;
}LinkStack;
//进栈
//栈顶
Status Push(LinkStack *S, ElemType e){
LinkStackPrt p = (LinkStackPrt)malloc(sizeof(StackNode));
p->data = e;
p->next = S->top;//将当前栈顶元素作为新节点 p 的直接后继
S->top = p;//p为新栈顶
S->count++;
return success;
}
//出栈
//栈顶
Status Pop(LinkStack *S, ElemType *e){
LinkStackPtr p;
if(StackEmpty(*S)){
return ERROR;
}
*e = S->top->data;
p = S->top;//将栈顶结点赋值给p
S->top = S->top->next;
free(p);//释放结点p
S->count--;
return success;
}
2.队列
队列只允许在一端进行插入操作,而在另一端进行删除操作的线性表。特点是先进先出。允许插入的一端称为队尾,允许删除的一端称为队头。
2.1 顺序队列
#define MAXSIZE 50 //定义队列中元素的最大个数
typedef struct{
ElemType data[MAXSIZE]; //存放队列元素
int front,rear;
}SqQueue;
2.2 循环队列
头尾相接的顺序存储结构。
typedef int ElemType;
#define MAXSIZE 50
/*循环队列的顺序存储结构*/
typedef struct{
ElemType data[MAXSIZE];
int front; //头指针
int rear; //尾指针,若队列不空,指向队列尾元素的下一个位置
}SqQueue;
//初始化
Status InitQueue(SqQueue *Q){
Q->front = 0;
Q->rear = 0;
return OK;
}
//判队空
bool isEmpty(SqQueue Q){
if(Q.rear == Q.front){
return true;
}else{
return false;
}
}
//队列长度
int QueueLength(SqQueue Q){
return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
}
//入队
Status EnQueue(SqQueue *Q, ElemType e){
if((Q->rear + 1) % MAXSIZE == Q->front){
return ERROR;//队满
}
Q->data[Q->rear] = e; //将元素e赋值给队尾
Q->rear = (Q->rear + 1) % MAXSIZE; //rear指针向后移一位置,若到最后则转到数组头部
return OK;
}
//出队
Status DeQueue(SqQueue *Q, ElemType *e){
if(isEmpty(Q)){
return REEOR; //队列空的判断
}
*e = Q->data[Q->front]; //将队头元素赋值给e
Q->front = (Q->front + 1) % MAXSIZE; //front指针向后移一位置,若到最后则转到数组头部
}
2.3 链队列
typedef struct {
ElemType data;
struct LinkNode *next;
}LinkNode;
//链队列
typedef struct{
LinkNode *front, *rear; //队列的队头和队尾指针
}LinkQueue;
//Q->front == NULL 并且 Q->rear == NULL 时,链队列为空
//初始化
void InitQueue(LinkQueue *Q){
Q->front = Q->rear = (LinkNode)malloc(sizeof(LinkNode));//建立头结点
Q->front->next = NULL; //初始为空
}
//入队
Status EnQueue(LinkQueue *Q, ElemType e){
LinkNode s = (LinkNode)malloc(sizeof(LinkNode));
s->data = e;
s->next = NULL;
Q->rear->next = s; //把拥有元素e新结点s赋值给原队尾结点的后继
Q->rear = s; //把当前的s设置为新的队尾结点
return OK;
}
//出队
Status DeQueue(LinkQueue *Q, Elemtype *e){
LinkNode p;
if(Q->front == Q->rear){
return ERROR;
}
p = Q->front->next; //将欲删除的队头结点暂存给p
*e = p->data; //将欲删除的队头结点的值赋值给e
Q->front->next = p->next; //将原队头结点的后继赋值给头结点后继
//若删除的队头是队尾,则删除后将rear指向头结点
if(Q->rear == p){
Q->rear = Q->front;
}
free(p);
return OK;
}
2.4 双端队列
两端都可以进行入队和出队操作的队列
在双端队列进队时,前端进的元素排列在队列中后端进的元素的前面,后端进的元素排列在队列中前端进的元素的后面。在双端队列出队时,无论是前端还是后端出队,先出的元素排列在后出的元素的前面。