王道数据结构—栈和队列的存储结构和基本操作

绵绵不眠

已于 2022-10-11 22:26:32 修改

阅读量414

点赞数

文章标签：数据结构 c语言算法

于 2022-10-11 22:25:38 首次发布

本文链接：https://blog.csdn.net/SSilverdeww/article/details/127254079

版权

文章目录

栈和队列

栈和队列

栈

1.顺序栈的存储结构和基本操作

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define MaxSize 50
typedef struct{
    int data[MaxSize];
    int top;
}SqStack;

//初始化
void InitStack(SqStack &S){
    S.top=-1;         //初始化栈顶指针
}

//判栈空
bool StackEmpty(SqStack S){
    if(S.top==-1)
        return true;
    else
        return false;
}

//进栈
bool Push(SqStack &S,int x){
    if(S.top==MaxSize-1) //栈满报错
        return false;
    S.data[++S.top]=x;   //指针先加1，再入栈
    return true;
}

//出栈
bool Pop(SqStack &S,int &x){
    if(S.top==-1)       //栈空，报错
        return false;
    x=S.data[S.top--];  //出栈，指针再减1
    return true;
}

//读栈顶元素
bool GetTop(SqStack S,int &x){
    if(S.top==-1)
        return false;
    x=S.data[S.top];
    return true;
}

int main(){
    SqStack S;
    int num=0;
    int x=0;
    int i=0;
    InitStack(S);
    printf("输入栈中元素个数：\n");
    scanf("%d",&num);
    printf("输入具体元素：\n");
    for(i=0;i<num;i++){
        scanf("%d",&x);
        Push(S,x);
    }
    printf("栈中元素为：\n");
    for(i=0;i<num;i++){
        printf("%d ",S.data[i]);
    }
    printf("\n");
    printf("出栈顺序为：\n");
    while(S.top!=-1){
        Pop(S,x);
        printf("%d ",x);
    }
    printf("\n");
    return 0;

}

2.共享栈

#define Maxsize 10
typedef struct{
   ElemType data[Maxsize];
   int top0;
   int top1;
}ShStack;
void InitStack(ShStack &S){
   S.top0=-1;
   S.top1=Maxsize;
}
bool isFull(ShStack S){
   if((S.top0+1)==S.top1)
       return true;
   else
       return false; 
}

3.链式存储

typedef struct Linknode{
   int data;               //数据域
   struct Linknode *next;  //指针域
}*LiStack;                 //栈类型定义

队列

1.顺序存储

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define MaxSize 10
typedef struct{
    int data[MaxSize];
    int front,rear;
}SqQueue;

/*
增加一个判断条件方法
typedef struct{
    int data[MaxSize];
    int front,rear;
    int size;//或者是tag=0;
}SqQueue;

//初始化
void InitQueue(SqQueue &Q){
    Q.front=Q.rear=0;
    Q.size=0;
}
//入队size+1或者tag=1，出队size-1或者tag=0

//判断队空
bool isEmpty(SqQueue Q){
    if(Q.rear==Q.front&&Q.size==0)    //队空判断条件
       //Q.rear==Q.front&&Q.tag==0
        return true;
    else
        return false;
}

//判断队满
bool isFull(SqQueue Q){
    if(Q.rear==Q.front&&Q.size!=0)
        //Q.rear==Q.front&&Q.tag==1
        return true;
    else
        return false;
}

*/

//牺牲一个存储单元法
//初始化
void InitQueue(SqQueue &Q){
    Q.front=Q.rear=0;
}

//判队空
bool isEmpty(SqQueue Q){
    if(Q.rear==Q.front)    //队空判断条件
        return true;
    else
        return false;
}

//入队
bool EnQueue(SqQueue &Q,int x){
    if((Q.rear+1)%MaxSize==Q.front)   //牺牲一个存储单元，队满判断条件
        return false;
    Q.data[Q.rear]=x;                 //队尾指针始终指向下一个要插入的元素的位置
    Q.rear=(Q.rear+1)%MaxSize;        //取模是因为存储空间在逻辑上是环状
    return true;
}

//出队
bool DeQueue(SqQueue &Q,int &x){
    if(Q.rear==Q.front)
        return false;
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;     //头指针后移，始终指向队列中即将出队的第一个元素
    return true;
}

//获得队头元素的值，用x返回
bool GetHead(SqQueue Q,int &x){
    if(Q.rear==Q.front)
        return false;
    x=Q.data[Q.front];
    return true;
}

//队列长度
int QueueLength(SqQueue Q){
    int num;
    num=(Q.rear+MaxSize-Q.front)%MaxSize;
    return num;
}

//打印队列中元素!!!!注意访问的方法！！！！！
/*void PrintQueue(SqQueue Q){
    int i=0;
    int sum=0;
    sum=QueueLength(Q);
    for(i=0;i<sum;i++)
        printf("%d ",Q.data[i]);
    printf("\n");
}*/
void PrintQueue(SqQueue Q){
    for(int i=Q.front;i!=Q.rear;i=(i+1)%MaxSize){
        printf("%d ",Q.data[i]);
    }
    printf("\n");
}

int main(){
    SqQueue Q;
    int x;
    int i=0;
    int num=0;
    InitQueue(Q);
    printf("输入队列长度：\n");
    scanf("%d",&num);
    printf("分别输入他们的值：\n");
    for(i=0;i<num;i++){
        scanf("%d",&x);
        EnQueue(Q,x);
    }
    printf("此时的队列为：\n");
    PrintQueue(Q);
    printf("对头两个元素出队，他们的值分别是：\n");
    DeQueue(Q,x);
    printf("%d ",x);
    DeQueue(Q,x);
    printf("%d ",x);
    printf("此时的队列为：\n");
    PrintQueue(Q);
    return 0;

}

2.链式存储

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef struct LinkNode{             //链式队列结点
    int data;
    struct LinkNode *next;
}LinkNode;
typedef struct{             //链式队列
    LinkNode *front,*rear;  //队列的队头和队尾指针
}LinkQueue;

/*
//不带头结点

//初始化
void InitQueue(LinkQueue &Q){
   Q.front=NULL;
   Q.rear=NULL;
}

//判断空
bool isEmpty(LinkQueue Q){
   if(Q.front==NULL)
      return true;
   else
      return false;
}

//入队
void EnQueue(LinkQueue &Q,int x){
   LinkNode *s= (LinkNode*)malloc(sizeof(LinkNode))
   s->data=x;
   s->next=NULL;
   if(Q.front==NULL){
    Q.front=s;
    Q.rear=s;
   }
   else{
    Q.rear->next=s;
    Q.front=s;
   }
}

//出队
bool DeQueue(LinkQueue &Q,int &x){
   if(Q.front==NULL)
      return false;
   LinkNode *p=Q.front;
   x=p->data;
   Q.front=p->next;
   if(Q.rear==p){
     Q.front=NULL;
     Q.rear=NULL;
   }
   free(p);
   return true;
}


*/

//带头结点
//初始化
void InitQueue(LinkQueue &Q){
    Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));
    Q.front->next=NULL;
}

//判断队空
bool isEmpty(LinkQueue Q){
    if(Q.front==Q.rear) return true;
    else return false;
}

//入队
void EnQueue(LinkQueue &Q,int x){
    LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    Q.rear->next=s;
    Q.rear=s;
}

//出队
bool DeQueue(LinkQueue &Q,int &x){
    if(Q.front==Q.rear) return false;
    LinkNode *p=Q.front->next;
    x=p->data;
    Q.front->next=p->next;
    if(Q.rear==p)
        Q.rear=Q.front;
    free(p);
    return true;
}

//打印队列元素
void PrintQueue(LinkQueue Q){
    LinkNode *p;
    p=Q.front;
    while(p->next!=NULL){
        p=p->next;
        printf("%d ",p->data);
    }
    printf("\n");
}

int main(){
    LinkQueue Q;
    int x,y;
    int i=0;
    InitQueue(Q);
    printf("输入队列长度：\n");
    scanf("%d",&x);
    printf("输入具体元素值：\n");
    for(i=0;i<x;i++){
        scanf("%d",&y);
        EnQueue(Q,y);
    }
    printf("此时队列中元素为：\n");
    PrintQueue(Q);
    printf("前两个元素出队，分别为：\n");
    for(i=0;i<2;i++){
        DeQueue(Q,y);
        printf("%d ",y);
    }
    printf("\n出队后的队列为：\n");
    PrintQueue(Q);
    return 0;
}

3.双端队列

应用

1.栈的应用

1-1 括号匹配

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define MaxSize 50
typedef struct{
    char data[MaxSize];
    int top;
}SqStack;

//初始化
void InitStack(SqStack &S){
    S.top=-1;         //初始化栈顶指针
}

//判栈空
bool StackEmpty(SqStack S){
    if(S.top==-1)
        return true;
    else
        return false;
}

//进栈
bool Push(SqStack &S,char x){
    if(S.top==MaxSize-1) //栈满报错
        return false;
    S.data[++S.top]=x;   //指针先加1，再入栈
    return true;
}

//出栈
bool Pop(SqStack &S,char &x){
    if(S.top==-1)       //栈空，报错
        return false;
    x=S.data[S.top--];  //出栈，指针再减1
    return true;
}

//读栈顶元素
bool GetTop(SqStack S,char &x){
    if(S.top==-1)
        return false;
    x=S.data[S.top];
    return true;
}

//打印栈
void PrintStack(SqStack S){
    int temp=S.top;
    while(temp!=-1){
        printf("%c ",S.data[temp--]);
    }
}

bool bracketCheck(char str[],int length){
    SqStack S;
    InitStack(S);
    int i=0;
    for(i=0;i<length;i++){
        if(str[i]=='('||str[i]=='['||str[i]=='{'){
            Push(S,str[i]);
        }
        else{
            if(StackEmpty(S)){
               return false;
            }
            char topElem;
            Pop(S,topElem);
            if(str[i]==')'&&topElem!='('){
                return false;
            }
            if(str[i]==']'&&topElem!='['){
                return false;
            }
            if(str[i]=='}'&&topElem!='{'){
                return false;
            }
        }
    }
    return StackEmpty(S);
}

int main(){
    int sum=6;
    char *str;
    int i=0;
    //printf("输入字符串长度：\n");
    //scanf("%d",&sum);
    str=(char*)malloc(sizeof(char)*sum);
    printf("输入6个半括号：\n");
    for(i=0;i<sum;i++){
       str[i]=getchar();
    }
    //for(i=0;i<sum;i++){
    //    printf("%d :%c ",i,str[i]);
    //}
    bool check;
    check=bracketCheck(str,6);
    if(check)
        printf("字符串的括号是匹配的\n");
    else
        printf("字符串的括号是不匹配的\n");
    return 0;
}