沈阳师范大学大二上数据结构--栈和队列

7-1 堆栈操作合法性 (10分)
假设以S和X分别表示入栈和出栈操作。如果根据一个仅由S和X构成的序列，对一个空堆栈进行操作，相应操作均可行（如没有出现删除时栈空）且最后状态也是栈空，则称该序列是合法的堆栈操作序列。请编写程序，输入S和X序列，判断该序列是否合法。

输入格式:
输入第一行给出两个正整数N和M，其中N是待测序列的个数，M（≤50）是堆栈的最大容量。随后N行，每行中给出一个仅由S和X构成的序列。序列保证不为空，且长度不超过100。

输出格式:
对每个序列，在一行中输出YES如果该序列是合法的堆栈操作序列，或NO如果不是。

输入样例：

4 10
SSSXXSXXSX
SSSXXSXXS
SSSSSSSSSSXSSXXXXXXXXXXX
SSSXXSXXX

输出样例：

YES
NO
NO
NO

#include<iostream>
#include<cstdio>
typedef struct MyStack* StackPoint;
struct MyStack
{
	StackPoint Next;
	char Data;
};
class ClassStack {
private:
	StackPoint Head;
	StackPoint P;
	int StackLength;
public:
	ClassStack() {
		this->Head = NULL;
	}
	void StackPush(char NewData) {
		StackPoint NewStack = (StackPoint)malloc(sizeof(MyStack));
		NewStack->Data = NewData;
		if (this->Head == NULL) {
			NewStack->Next = NULL;
			this->Head = NewStack;
			this->P = NewStack;
		}
		else
		{
			NewStack->Next = this->P;
			this->P = NewStack;
		}
		this->StackLength++;
	}
	void StackPop() {
		char ReturnData;
		StackPoint DeleteStack;
		DeleteStack = this->P;
		ReturnData = this->P->Data;
		this->P = this->P->Next;
		delete(DeleteStack);
		this->StackLength--;
	}
	int GetStackLength() {
		return this->StackLength;
	}
};
int main() {
	int num1, num2;
	std::cin >> num1 >> num2;
	getchar();
	for (int i = 0; i < num1; i++) {
		ClassStack* StackFirstPoint = new ClassStack();
		bool Stat = true;
		char Option;
		Option = getchar();
		while (Option != '\n')
		{
			if (Option == 'S') {
				StackFirstPoint->StackPush('T');
				if ((StackFirstPoint->GetStackLength()) > num2) {
					Stat = false;
				}
			}
			if (Option == 'X') {
				if ((StackFirstPoint->GetStackLength() - 1) < 0) {
					Stat = false;
				}
				else
				{
					StackFirstPoint->StackPop();
				}
			}
			Option = getchar();
		}
		if (StackFirstPoint->GetStackLength() != 0) {
			Stat = false;
		}
		if (Stat == false) {
			std::cout << "NO\n";
		}
		else
		{
			std::cout << "YES\n";
		}
	}
}

7-4 括号匹配 (10分)
检查一段C语言代码的小括号( )、 中括号 [ ] 和大括号{ } 是否匹配。

输入格式:
在一行中输入一段C语言代码，长度不超过1000个字符（行末以换行符结束）。

输出格式:
第一行输出左括号的数量和右括号的数量，中间以一个空格间隔。
若括号是匹配的，在第二行打印YES，否则打印NO。

输入样例1:

for(int i=0; i<v; i++){ visited[i] = 0; for(int j=0; j<v; j++) scanf("%d",&(g->Adj[i][j])); }

输出样例1:

8 8
YES

输入样例2:

for(int i=0; i<v; i++) a(i]=0;

输出样例2:

2 2
NO

#include<iostream>
#include<cstdio>
typedef struct Node* NodePoint;
typedef class Stack* StackPoint;
struct Node{
    char data;
    NodePoint Link;
};
class Stack{
private:
    NodePoint head;
    NodePoint p;
    int StackLength;
    int Left;
    int Right;
public:
    Stack(){
        this->head=NULL;
        this->StackLength=0;
        this->Left=0;
        this->Right=0;
    }
    void LeftAdd(){
        this->Left++;
    }
    void RightAdd(){
        this->Right++;
    }
    int GetLeft(){
        return this->Left;
    }
    int GetRight(){
        return this->Right;
    }
    int GetLength(){
        return this->StackLength;
    }
    void StackPush(char data){
        NodePoint NewNode=new Node;
        NewNode->data=data;
        if(this->head==NULL){
            NewNode->Link=NULL;
            this->head=NewNode;
            this->p=NewNode;
        } else{
            NewNode->Link=this->p;
            this->p=NewNode;
        }
        this->StackLength++;
    }
    char StackPop(){
        if(this->StackLength<=0){
            abort();
        }
        NodePoint DeleteNode;
        char data;
        DeleteNode=this->p;
        data=p->data;
        this->p=this->p->Link;
        delete (DeleteNode);
        this->StackLength--;
        return data;
    }
};
bool Varify(char data1,StackPoint* s1){
    bool stat=true;
    char var1;
    if((*s1)->GetLength()<=0){
        stat= false;
        return stat;
    }
    if((*s1)->GetLength()>0) {
        var1 = (*s1)->StackPop();
    }
    if(data1==')'&&var1!='('){
        stat= false;
    }
    if(data1=='}'&&var1!='{'){
        stat= false;
    }
    if(data1==']'&&var1!='['){
        stat= false;
    }
    return stat;
}
void PrintNode(StackPoint* s1){
    while ((*s1)->GetLength()>0){
        std::cout<<(*s1)->StackPop();
    }
}
bool ReadNode(){
    bool stat= true;
    char data1;
    StackPoint s1=new Stack();
    data1=getchar();
    while (data1!='\n'){
        if(data1=='['||data1=='{'||data1=='('){
            s1->StackPush(data1);
            s1->LeftAdd();
        }
        if(data1==']'||data1=='}'||data1==')'){
            s1->RightAdd();
            stat=Varify(data1,&s1);
        }
        data1=getchar();
    }
if(s1->GetRight()!=s1->GetLeft()){
    stat= false;
}
std::cout<<s1->GetLeft()<<" "<<s1->GetRight()<<"\n";
    return stat;
}
int main(){
    bool stat;
    stat=ReadNode();
    if(stat== false){
        std::cout<<"NO";
    } else{
        std::cout<<"YES";
    }
}

7-5 队列操作 (10分)
请实现一个MyQueue类，实现出队，入队，求队列长度.

实现入队函数 void push(int x); 实现出队函数 int pop(); 实现求队列长度函数 int size();

输入格式:
每个输入包含1个测试用例。每个测试用例第一行给出一个正整数 n (n <= 10^6) ，接下去n行每行一个数字，表示一种操作： 1 x ： 表示从队尾插入x，0<=x<=2^31-1。 2 ： 表示队首元素出队。 3 ： 表示求队列长度。

输出格式:
对于操作2,若队列为空，则输出 “Invalid”,否则请输出队首元素。 对于操作3，请输出队列长度。 每个输出项最后换行。

输入样例:

5
3
2
1 100
3
2

输出样例:

0
Invalid
1
100

#include <iostream>
#include<cstdio>
typedef struct MyNode* NodePoint;
struct MyNode{
    long long int data;
    NodePoint link;
};
class MyQuene{
    int Length;
    NodePoint P;
public:
    NodePoint FirstP;
    void push(long long int x){
        this->P->data=x;
        NodePoint P0=(NodePoint)malloc(sizeof(struct MyNode));
        P0->link=NULL;
        this->P->link=P0;
        this->P=P0;
        this->Length++;
    }
    int pop(){
        if(this->FirstP->link!=NULL){
            int num=this->FirstP->data;
            this->FirstP=this->FirstP->link;
            this->Length--;
            return num;
        }
    }
    int size(){
        return this->Length;
    }
    MyQuene(){
        this->Length=0;
        this->P=(NodePoint)malloc(sizeof(struct MyNode));
        this->P->link=NULL;
        this->FirstP=P;
    }
};
int main(){
    int Num=0;
    std::cin>>Num;
    MyQuene* q1=new MyQuene();
    for(int i=0;i<Num;i++){
        int control=0;
        std::cin>>control;
        switch (control) {
            case 1:
            {long long int tempnum=0;
            std::cin>>tempnum;
            (q1)->push(tempnum);}
                break;
            case 2:{
                int tempnum=0;
                if((q1)->FirstP->link==NULL){
                    std::cout<<"Invalid"<<'\n';
                } else{
                    tempnum=(q1)->pop();
                    std::cout<<tempnum<<"\n";
                }
            }
                break;
            case 3:{
                std::cout<<(q1)->size()<<"\n";
            }
                break;

        }
    }
}