大一下 数据结构 清华严蔚敏(C语言)版 学习记录——栈和队列

 用栈实现括号匹配判断

#include<bits/stdc++.h>
#define STACK_INIT_SIZE 100//栈的长度
#define STACKINCREMENT 10//每次增加的长度
#define OK 1
#define OVERFLOW -2
#define ERROR 0
typedef char SElemType;
typedef int Status;
//---------------------------------------结构体定义区--------------------------------
typedef struct {
	SElemType *base;//栈底指针，栈构造前和销毁后都为空
	SElemType *top;//栈顶指针，指向栈顶元素的下一位置
	int stacksize;//当前分配的栈的存储空间数
}SqStack;
//----------------------------------------函数定义区---------------------------------
Status GetTop(SqStack S,SElemType &e)
{
	if(S.top==S.base) return ERROR;
	e=*(S.top-1);
	return OK;
}

Status InitStack(SqStack &S)//初始化函数
{
	S.base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
	if(!S.base) exit(OVERFLOW);//代码健壮性检验
	S.top= S.base;//赋初值——栈顶=栈尾
	S.stacksize = STACK_INIT_SIZE;//栈长初始化
	return OK;
}

Status StackEmpty(SqStack S)//栈空函数
{
	return S.top == S.base;//栈空时候头为尾
}

Status Push(SqStack &S, SElemType e)//压栈函数
{
	if(S.top - S.base>=S.stacksize)
	    return ERROR;
    *S.top++ = e;//向top指针指向的空间赋值，赋完后指针top后移一位
    return OK;
}

Status Pop(SqStack &S, SElemType &e)//弹出函数
{
	if(S.base == S.top) return ERROR;
	e = *--S.top;
	return OK;
}

Status Match(char *st)//匹配括号函数
{
	SqStack S;
	InitStack(S);
	SElemType e;
	int flag = 1,i = 0;
	while(st[i])
	{
		switch(st[i])//字符串有值
		{
			case '(':
			case '[':
			case '{':
			    Push(S,st[i]);//只要是左括号就全压入栈
			    break;
            case ')':
            case '}':
            case ']':
                if(StackEmpty(S))//如果栈是空的话（右括号先进来的情况），flag=0
                {
                	flag = 0;
                	break;
                }
                Pop(S,e);
                if(!(e == '('&&st[i] == ')'||e == '['&&st[i] == ']'||e == '{'&&st[i] == '}'))
                {//左右不匹配的情况
                	flag = 0;
                	break;
                }
		}
		if(!flag) break;
		i++;
	}
	if(flag && StackEmpty(S))//标志为True且所有括号匹配完
	    return true;
    else
        return false;
}
//--------------------------------------主函数区---------------------------------------
int main(){
	char st[1000];
	while(gets(st))
	{
		if(Match(st)) printf("yes\n");
		else printf("no\n");
	}
	return 0;
}

循环队列的创建

第一种方法：

#include <bits/stdc++.h>
using namespace std;
typedef int QElemType;
typedef int Status;
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXQSIZE 100001//最大队列长度
int head=0,tail=0,flag=0;//flag=0表示未满
int a[MAXQSIZE];
char s[20];
//---------------------------------------结构体定义区--------------------------------
typedef struct QNode{
    QElemType data;
    struct QNode *next;
}QNode,*QueuePtr;
typedef struct{
    QueuePtr front;//对头指针
    QueuePtr rear;//队尾指针
}LinkQueue;
typedef struct{
    QElemType *base;//初始化的动态分配内存空间
    int front;//头指针，若队列不空，则指向队头元素
    int rear;//尾指针，若队列不空，指向队列尾元素的下一个位置
}SqQueue;
//---------------------------------------函数声明区--------------------------------
Status InitQueue(LinkQueue &Q);//构造一个空队列Q
Status QueueLength(SqQueue Q);//返回Q的元素个数，即队列的长度
Status DestroyQueue(LinkQueue &Q);//销毁队列Q
Status EnQueue(LinkQueue &Q,QElemType e);//插入元素e为Q的新的队尾元素
Status EnQueue(int x);//入队
Status DeQueue(LinkQueue &Q,QElemType &e);//队头元素出队
Status DeQueue();//队头元素出队
//---------------------------------------函数定义区--------------------------------
/* Status InitQueue(LinkQueue &Q)//构造一个链式空队列Q
{
     Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
     if(!Q.front)exit(OVERFLOW);
     Q.front->next=NULL;
     return OK;
} */

Status InitQueue(SqQueue &Q)//构造一个循环空队列Q
{
    Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));
    if(!Q.base)exit(OVERFLOW);
    Q.front=Q.rear=0;
    return OK;
}

Status QueueLength(SqQueue Q)//返回Q的元素个数，即队列的长度
{
    return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}

/* Status EnQueue(LinkQueue &Q,QElemType e)//插入元素e为Q的新的队尾元素
{
    if((Q.rear+1)%MAXQSIZE==Q.front) return ERROR;//队列满
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%MAXQSIZE;
    return OK;

} */

Status EnQueue(int x)//入队
{
    if(tail==head&&flag==1) return 0;//队满
    tail=(tail+1)%MAXQSIZE;
    a[tail]=x;
    if(tail==head) flag=1;
    return 0;
}

/* Status DeQueue(LinkQueue &Q,QElemType &e)//队头元素出队
{
    //若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；
    //否则返回ERRORERROR
    QueuePtr p;
    if(Q.front==Q.rear) return ERROR;
    p=Q.front->next;
    e=p->data;
    Q.front->next=p->next;
    if(Q.rear==p) Q.rear=Q.front;
    free(p);
    return OK;
} */

Status DeQueue()//队头元素出队
{
    if(head==tail&&flag==0) return -1;
    int e;
    head=(head+1)%MAXQSIZE;
    e=a[head];
    if(head==tail) flag=0;
    return e;
}

Status DestroyQueue(LinkQueue &Q)//销毁队列Q
{
    while(Q.front)
    {
        Q.rear=Q.front->next;
        free(Q.front);
        Q.front=Q.rear;
    }
    return OK;
}

/* Status EnQueue(LinkQueue &Q,QElemType e)//插入元素e为Q的新的队尾元素
{
    QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
    if(!p) exit(OVERFLOW);
    p->data=e; p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
    return OK;
} */

//---------------------------------------主函数区-----------------------------------
int main() {
    int n,x,t;scanf("%d",&n);
    while(n--)
    {
        scanf("%s",&s);
       //printf("%s\n",a);
       if(s[0]=='e')
       {
            scanf("%d",&x);
            EnQueue(x);
       }
       else if(s[0]=='d')
       {
           t=DeQueue();
           printf("%d\n",t);
       }
    }
    return 0;
}