【数据结构】栈和队列

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 双端队列

两端都可以进行入队和出队操作的队列

在双端队列进队时，前端进的元素排列在队列中后端进的元素的前面，后端进的元素排列在队列中前端进的元素的后面。在双端队列出队时，无论是前端还是后端出队，先出的元素排列在后出的元素的前面。