数据结构C++语言版 -- 栈和队列

大二学生的 C++数据结构 有部分Openjudge提交的代码没有删除

邮箱：liu_772021@yeah.net

欢迎交流讨论~

有用的话，点赞留言就可以表示感谢啦~

//
//  main.cpp
//  Stack and Queue
//
//  Created by Liu_77 on 2021/12/15.
//

#include <iostream>
#include <cstring>

using namespace std;

#define MAXSIZE 100
typedef int ElemType;

//栈的结构体声明
typedef struct {
    //保存栈的元素
    ElemType data[MAXSIZE];
    //栈顶指针
    int top;
}SqStack;

//队列的结构体声明
typedef struct{
    ElemType data[MAXSIZE];
    int front,rear;
}SqQueue;

//初始化栈算法：设定栈顶指针top = -1（清空栈）
void InitStack(SqStack &st){
    st.top = -1;
}

//销毁栈：系统自动释放空间
void DestroyStack(SqStack st){
    
}

//进栈算法
int Push(SqStack &st,ElemType x){
    //如果栈已满，上溢出，返回-1
    if(st.top == MAXSIZE - 1){
        return 0;
    }
    else{
        st.top++;
        st.data[st.top] = x;
        return 1;
    }
}

//出栈算法
int Pop(SqStack &st,ElemType &x){
    if(st.top == -1){
        return 0;
    }
    else{
        x = st.data[st.top];
        st.top--;
        return 1;
    }
}

//重载Pop，char型返回x
int Pop(SqStack &st,char &x){
    if(st.top == -1){
        return 0;
    }
    else{
        x = st.data[st.top];
        st.top--;
        return 1;
    }
}

//获取栈顶元素
int GetTop(SqStack st,ElemType &x){
    if(st.top == -1) return 0;
    else{
        x = st.data[st.top];
        return 1;
    }
}

//判断栈空算法
int StackEmpty(SqStack st){
    if(st.top == -1) return 1;
    else return 0;
}

//栈的链式存储结构
typedef struct node{
    //存储结点数据
    ElemType data;
    //指针域：自顶指向下。
    struct node *next;
}LinkStack;
//栈空条件：LS == NULL
//栈满条件：不考虑

//销毁栈运算算法
void DestroyStack_L(LinkStack *&ls,ElemType x){
    LinkStack *pre = ls,*p;
    if(pre == NULL) return;
    p = pre->next;
    while(p != NULL){
        free(pre);
        pre = p;
        p = p->next;
    }
    free(pre);
}

//进栈算法
int Push_L(LinkStack *&ls,ElemType x){
    LinkStack *p;
    p = (LinkStack *)malloc(sizeof(LinkStack));
    p->data = x;
    p->next = ls;
    ls = p;
    return 1;
}

//出栈算法
//ls是链栈的顶指针。
int Pop_L(LinkStack *&ls,ElemType &x){
    LinkStack *p;
    if(ls == NULL) return 0;
    else{
        p = ls;
        x = p->data;
        ls = p->next;
        free(p);
        return 1;
    }
}

//获取栈顶元素
int GetTop_L(LinkStack *ls,ElemType &x){
    if(ls == NULL) return 0;
    else{
        x = ls->data;
        return 1;
    }
}

//判断栈空
int StackEmpty_L(LinkStack *ls){
    if(ls == NULL) return 1;
    else return 0;
}

//判断进栈出栈操作是否合法；I表示进展，O表示出栈。
//str是输入的字符串；n是字符串长度。
int Judge(char str[],int n){
    int i;
    ElemType x;
    SqStack st;
    InitStack(st);
    for(i = 0;i<n;i++){
        if(str[i] == 'I'){
            Push(st,str[i]);
        }
        else if(str[i] == 'O'){
            if(!Pop(st,x)){
                DestroyStack(st);
                return 0;
            }
        }
    }
    if(StackEmpty(st)){
        DestroyStack(st);
        return 1;
    }
    else{
        DestroyStack(st);
        return 0;
    }
}

//判断字符串是否是回文字符串;n是字符串长度
int Palindrome(char str[],int n){
    SqStack st;
    InitStack(st);
    int i;
    char ch;
    //进栈所有字符
    for(i = 0;i<n;i++){
        Push(st,str[i]);
    }
    
    //从头遍历字符串，直道栈空
    i = 0;
    while(!StackEmpty(st)){
        Pop(st,ch);
        //先判断是否相等，再自加i。
        if(ch != str[i++]){
            //出现不相等的，不是回文字符串，返回0
            DestroyStack(st);
            return 0;
        }
    }
    //全部判断完毕，是回文字符串，返回1
    DestroyStack(st);
    return 1;
}

//自己写的，进栈一半判断回文
int Palindrome_2(char str[],int n){
    SqStack st;
    InitStack(st);
    int i;
    char ch;
    //进栈前面一半字符串
    //奇数个，正中间的字符无需进栈判断；偶数个则刚好需要进栈。
    for(i = 0;i<(n/2);i++){
        Push(st,str[i]);
    }
    if(n%2 == 1){
        i++;
    }
    
    //继续遍历字符串，直到栈空（字符串也恰好遍历完）
    while(!StackEmpty(st)){
        Pop(st,ch);
        //先判断是否相等，再自加i。
        if(ch != str[i++]){
            //出现不相等的，不是回文字符串，返回0
            DestroyStack(st);
            return 0;
        }
    }
    //全部判断完毕，是回文字符串，返回1
    DestroyStack(st);
    return 1;
}


//括号匹配算法
int Match(char exp[],unsigned long n){
    SqStack st;
    InitStack(st);
    int flag = 1,i = 0;
    char ch;
    
    //括号匹配部分：出现不匹配，则flag = 0，跳出循环；直到整个字符串遍历完毕
    //快速算法：出现不匹配即跳出；但不能知道哪种括号不匹配。
    /*
    while(i<n && flag == 1){
        switch(exp[i]){
            case'(':case'[':case'{':
                Push(st,exp[i]);break;
            case')':
                if(!Pop(st,ch) || ch != '(') flag = 0;break;
            case']':
                if(!Pop(st,ch) || ch != '[') flag = 0;break;
            case'}':
                if(!Pop(st,ch) || ch != '{') flag = 0;break;
        }
        i++;
    }
     */
    
    int left = 0,right = 0;
    while(i<n){
        switch(exp[i]){
            case'(':case'[':case'{':{
                left++;
                Push(st,exp[i]);
            }
                break;
            case')':{
                right++;
                if(!Pop(st,ch) || ch != '(') flag = 0;
            }
                break;
            case']':{
                right++;
                if(!Pop(st,ch) || ch != '[') flag = 0;
            }
                break;
            case'}':{
                right++;
                if(!Pop(st,ch) || ch != '{') flag = 0;
            }
                break;
        }
        i++;
    }
    
    if(left > right){
        cout<<"Extra left brackets\n";
        DestroyStack(st); return 0;
    }
    else if(left < right){
        cout<<"Extra right brackets\n";
        DestroyStack(st); return 0;
    }
    
    //如果栈空且括号匹配，返回1
    if(StackEmpty(st) && flag == 1){
        cout<<"Brackets match\n";
        DestroyStack(st); return 1;
    }
    //否则，抛出第一个多余字符，返回0
    else{
        cout<<"Brackets not match\n";
        DestroyStack(st); return 0;
    }
}

void DispStr(char *a,unsigned long length){
    printf("The list you have input: ");
    for(int i = 0;i<length;i++){
        printf("%c ",*(a+i));
    }
    printf(",\nThe Answer is:\n");
}

//利用栈，十进制转8进制：
//最后利用栈输出：利用了栈的先进后出特点，完成短除法中的 余数“倒着取”，获得正确结果。
void tenToEight(SqStack &st, int num_Ten) {
    //短除法，当最终结果还不为0，循环:
    while (num_Ten != 0) {
        //将当前数字模【8】，进栈。
        Push(st, num_Ten % 8);
        //更新当前数字：除以8取整数，继续短除。
        num_Ten /= 8;
    }
    return;
}

//-----------队列----------------
//初始化队列算法
void InitQueue(SqQueue &sq){
    sq.rear = sq.front = 0;
}

//销毁队列运算算法
void DestroyQueue(SqQueue sq){
    
}

//进队运算算法
int EnQueue(SqQueue &sq,ElemType x){
    //队满上溢出：队尾+1对最大长度取余，如果等于队首的标记，则相当于“追尾”，队伍满了
    if((sq.rear+1)%MAXSIZE == sq.front){
        return 0;
    }
    //若不满，【循环】进1.
    sq.rear = (sq.rear+1)%MAXSIZE;
    sq.data[sq.rear] = x;
    return 1;
}

//出队运算算法
int DeQueue(SqQueue &sq,ElemType &x){
    //队空下溢出
    if(sq.rear == sq.front){
        return 0;
    }
    //队头循环进1，出队
    sq.front = (sq.front+1)%MAXSIZE;
    x = sq.data[sq.front];
    return 1;
}

//取队头元素算法
int GetHead(SqQueue sq,ElemType &x){
    //队空下溢出
    if(sq.rear == sq.front){
        return 0;
    }
    //将队列头指针前一个位置的元素赋给x
    x = sq.data[(sq.front+1)%MAXSIZE];
    return 1;
}

int QueueEmpty(SqQueue sq){
    if(sq.rear == sq.front) return 1;
    else return 0;
}

//----------队列的链式存储结构-------------------
//链队中的数据结点的类型声明：
typedef struct QNode{
    //存放队中元素
    ElemType data;
    //指向下一个结点的指针
    struct QNode *next;
}QType;

//链队结点声明：
typedef struct qptr{
    //队头指针
    QType *front;
    //队尾指针
    QType *rear;
}LinkQueue;
//实际上是带有对头指针和队尾指针的【单链表】，队尾指针指向队尾结点即最后一个结点
//队头结点和队尾结点结合起来构成链队结点

//队空条件：lq->front == NULL
//堆满条件：不考虑
//进队操作：创建结点p，将其插入队尾（尾插法），并由lq->rear指向它。
//出队操作：删除队头结点

//初始化队列运算：
void InitQueue(LinkQueue *&lq){
    lq = (LinkQueue *)malloc(sizeof(LinkQueue));
    lq->rear = lq->front = NULL;
}

//销毁队列运算算法
void DestroyQueue(LinkQueue *&lq){
    QType *pre = lq->front,*p;
    //非空队列情况
    if(pre != NULL){
        //只有一个数据结点情况
        if(pre == lq->rear){
            //释放pre结点
            free(pre);
        }
        //有两个及以上结点情况：
        else{
            //pre->next不为空：
            p = pre->next;
            //直到pre后面的队空，循环暂停
            while(p != NULL){
                free(pre);
                //pre、p同步后移
                pre = p;
                p = p->next;
            }
            free(pre);
        }
    }
    //释放链队结点
    free(lq);
}

//进队运算算法
int EnQueue(LinkQueue *&lq,ElemType x){
    QType *s;
    //创建新结点s，插入到链队队尾
    s = (QType *)malloc(sizeof(QType));
    s->data = x;
    s->next = NULL;
    //原队尚为空队，front和rear均指向s结点；
    if(lq->front == NULL){
        lq->rear = lq->front = s;
    }
    //原队不为空：
    else{
        //将s结点链接到队尾
        lq->rear->next = s;
        //更新队尾指针rear指向s
        lq->rear = s;
    }
    return 1;
}

int DeQueue(LinkQueue *&lq,ElemType x){
    QType *p;
    if(lq->front == NULL){
        return 0;
    }
    //p指向队头结点；
    p = lq->front;
    //取队头元素值
    x = p->data;
    //链队只剩有一个结点
    if(lq->rear == lq->front){
        //出队该结点后，队列变空
        lq->rear = lq->front = NULL;
    }
    //链队有两个及以上结点
    else{
        //出队该结点，lq指向该结点后链结点（更新front域）
        lq->front = lq->front->next;
    }
    free(p);
    return 1;
}

//取队头元素运算算法
int GetHeaf(LinkQueue *lq,ElemType &x){
    //队空，返回0
    if(lq->front == NULL){
        return 0;
    }
    //队不空引用型变量传回x，返回1
    x = lq->front->data;
    return 1;
}

//判断队空运算算法
int QueueEmpty(LinkQueue *lq){
    if(lq->front == NULL){
        return 1;
    }
    else return 0;
}

//=----------用循环单链表表示链队-----------
typedef struct CycNode{
    ElemType data;
    struct CycNode *next;
}Qnode;
//循环单链表不带头结点，lq始终指向尾结点，lq->next为队头结点。lq == NULL时队列为空，lq->next表示只有一个结点

//初始化队列
void InitQueue(QNode *&lq){
    lq = NULL;
}

//销毁队列
void DesTroyQueue(QNode *&lq){
    QNode *pre,*p;
    if(lq != NULL){
        //当原队只有一个结点
        if(lq->next == lq){
            free(lq);
        }
        //原队中有两个以上结点
        else{
            pre = lq;
            p = pre->next;
            while(p != lq){
                //释放、pre、p同步后移
                free(pre);
                pre = p;
                p = p->next;
            }
            //释放最后一个结点
            free(pre);
        }
    }
}

//进队运算算法
void EnQueue(QNode *&lq,ElemType x){
    QNode *s;
    s = (QNode *)malloc(sizeof(QNode));
    s->data = x;
    //原队为空
    if(lq == NULL){
        lq = s;
        lq->next = lq;
    }
    //原队不空，结点s插到队尾，lq指向它
    else{
        //赋新结点指针域：指向头结点，即lq->next
        s->next = lq->next;
        //将s插入队尾，即令尾结点的指针域指向s
        lq->next = s;
        //更新尾结点为s
        lq = s;
    }
}

//出队运算算法
int DeQueue(QNode *&lq,ElemType x){
    QNode *s;
    if(lq == NULL) return 0;
    if(lq->next == lq){
        x = lq->data;
        free(lq);
        lq = NULL;
    }
    else{
        s = lq->next;
        x = s->data;
        lq->next = s->next;
        free(s);
    }
    return 1;
}

//取队头元素运算算法
int GetHead(QNode *lq,ElemType x){
    if(lq == NULL){
        return 0;
    }
    x = lq->next->data;
    return 1;
}

//判断队空运算算法
int QueueEmpty(QNode *lq){
    if(lq == NULL) return 1;
    else return 0;
}

//队列的应用示例
//输出队中所有元素
int DispAllQueue(QNode *lq){
    QNode *p;
    if(QueueEmpty(lq)){
        return 0;
    }
    else{
        p = lq->next;
        while(p != lq){
            printf("%d ",p->data);
            p = p->next;
        }
        printf("%d\n",lq->data);
    }
    return 1;
}

int main(int argc, const char * argv[]) {
    string s;
    cin >> s;
    
    unsigned long length = s.length();
    char *a = (char *)malloc(sizeof(char)*length);
    strcpy(a, s.c_str());
    cout<<"length = "<<length<<endl;
    DispStr(a, length);
    Match(a,length);
    return 0;
}

就可以表示感谢啦