西工大数据结构理论NOJ的第三部分，栈和队列的操作

最新推荐文章于 2024-09-13 19:36:07 发布

CoderGirl∞

最新推荐文章于 2024-09-13 19:36:07 发布

阅读量93

点赞数

分类专栏： #西工大理论数据结构NOJ# 文章标签：数据结构数学建模 c++

本文链接：https://blog.csdn.net/qq_65892509/article/details/131333230

版权

#西工大理论数据结构NOJ# 专栏收录该内容

6 篇文章 2 订阅

订阅专栏

#include<iostream>
#include<vector>
using namespace std;
int match(char a, char b)
{
	if ((a == '[') && (b == ']'))
		return 1;
	else if ((a == '(') && (b == ')'))
		return 1;
	else if ((a == '{') &&( b == '}'))
		return 1;
	return 0;
}
int main()
{
	vector<char>s;
	string str;
	cin >> str;
	for (int i = 0; i < str.length(); i++)
	{
		switch (str[i])
		{
		case'(':
		case'[':
		case'{':
			s.push_back(str[i]);
			break;
		case')':
		case']':
		case'}':
			if (s.empty())
			{
				cout << "no" << endl;
				return 0;
			}
			else
			{
				char a = s.back();
				if (match(a,str[i]))
				{
					s.pop_back(); //如果匹配成功则s栈顶的元素出栈
				}
				else
				{
					cout << "no" << endl;
					return 0;
				}
			}
		default:break;
		}
	}
	if (s.empty())
		cout << "yes";
	return 0;
}

用C语言完成：

#include <stdio.h>
#define MAXSIZE 100
typedef struct seqstack {
    char ele[MAXSIZE];
    int length = 0;
    int top = 0;
}seqstack, * pseqstack;
void push(pseqstack S, char e)
{
    if (S->length == MAXSIZE)
        return;//栈已满
    S->top++;
    S->ele[S->top] = e;
    S->length++;

}
void pop(pseqstack S)
{
    if (S->length != 0)
    {
        S->top--;
        S->length--;
    }
}
char getpop(pseqstack S)
{
    if (S->length != 0)
    {
        char c = S->ele[S->top];
        return c;
    }
    return '\0';
}
int isempty(pseqstack S)
{
    if (S->length == 0)
        return 1;
    else
        return 0;
}
int match(char c1, char c2)
{
    if (c1 == '(' && c2 == ')')
        return 1;
    if (c1 == '[' && c2 == ']')
        return 1;
    if (c1 == '{' && c2 == '}')
        return 1;
    return 0;
}
int main()
{
    seqstack S;
    char c = getchar();
    while (c != '\n')
    {
        switch (c)
        {
        case'(':
        case'[':
        case'{':
            push(&S, c);
            break;
        case')':
        case']':
        case'}':
            if (isempty(&S))
            {
                printf("no\n");
                return 0;
            }
            else
            {
                char t = getpop(&S);
                if (match(t, c))
                {
                    pop(&S);
                }
                else
                {
                    printf("no\n");
                    return 0;
                }
            }
            break;
        default:
            break;
        }
        c = getchar();
    }
    if (isempty(&S))
        printf("yes\n");
    return 0;
}

#include<iostream>
#include<string>
#include<vector>
using namespace std;
bool cpr(char a, char b)//如果a的优先级大于等于b的优先级，返回真
{
	if (a == '(') 
		return false;
	if (b == '+' || b == '-' || a == '*' || a == '/') 
		return true;
	return false;
}
int main()
{
	vector<char>ch;
	vector<char>num;
	string s;
	cin >> s;
	int length = s.length();
	for (int i = 0; i < length; i++)
	{
		if (s[i] >= 'a' && s[i] <= 'z')
		{
		   num.push_back(s[i]);
		}
		else if(s[i] == '(')
		{
			ch.push_back(s[i]);
		}
		else if (s[i] == ')')
		{
			while (ch.back() != '(')
			{
				num.push_back(ch.back());
				ch.pop_back();
			}
			ch.pop_back();
		}
		else
		{
			if (ch.empty())
				ch.push_back(s[i]);
			else
			{
				while (!ch.empty() && cpr(ch.back(), s[i]))
				{
					num.push_back(ch.back());
					ch.pop_back();
				}
				ch.push_back(s[i]);
			}
		}
	}
	while (!ch.empty())
	{
		num.push_back(ch.back());
		ch.pop_back();
	}
	for (vector<char>::iterator it = num.begin(); it < num.end(); it++)
	{
		cout << *it;
	}
	return 0;
}

C语言完成

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 20
typedef struct seqstack {
    char ele[MAXSIZE];
    int length = 0;
    int top = 0;
}seqstack, * pstack;
int cpr(char a, char b)//如果a(当前栈顶)的优先级大于b(当前字符)的优先级返回1
{
    if (a == '(')
        return 0;
    if ((a == '*' || a == '/') && (b == '+' || b == '-'))
        return 1;
    return 0;
}
void push(pstack S, char e)
{
    if (S->length == MAXSIZE)
    {
        printf("栈已满\n");
        return;
    }
        S->top++;
        S->ele[S->top] = e;
        S->length++;
}
void pop(pstack S)
{
    if (S->length != 0)
    {
        S->top--;
        S->length--;
    }
    else
        printf("栈为空\n");
}
void display(pstack S)
{
    for (int i = 1; i <= S->length; i++)
    {
        printf("%c", S->ele[i]);
    }
}
char getpop(pstack S)
{
    if (S->length != 0)
        return S->ele[S->top];
    else
        printf("栈为空\n");
    return '\0';
}
int isempty(pstack S)
{
    if (S->length == 0)
        return 1;
    else
        return 0;
}
int main()
{
    seqstack op;
    seqstack data;
    char c;
    c = getchar();
    while (c != '\n')
    {
        if ((c>= 'a') &&(c<= 'z'))
            push(&data, c);
        else if (c == '(')
            push(&op, c);
        else if (c == ')')
        {
            while (getpop(&op) != '(')
            {
                push(&data, getpop(&op));
                pop(&op);
            }
            pop(&op);
        }
        else
        {
            if (isempty(&op))
                push(&op, c);
            else
            {
                while (!isempty(&op) && cpr(getpop(&op), c))//当前运算符优先级小
                {
                    push(&data, getpop(&op));
                    pop(&op);
                }
                push(&op, c);
            }
        }
        c = getchar();
    }
    while (!isempty(&op))
    {
        push(&data, getpop(&op));
        pop(&op);
    }
    display(&data);
    return 0;
}

#include<stdio.h>
#include<stdlib.h>
typedef struct node {
    int data;
    struct node* next;
}node;
typedef struct Queue {
    struct node* rear;
    int length;
}Queue;
Queue* create()
{
    Queue* qptr = (Queue*)malloc(sizeof(Queue));
    if (!qptr)
    {
        printf("create error!\n");
    }
    else
    {
        qptr->rear = NULL;
        qptr->length = 0;
    }
    //printf("create success\n");
    return qptr;
}
void push(Queue* qptr, int e)
{
    node* p = (node*)malloc(sizeof(node));
    if (!p)
    {
        //printf("push error\n");
        return;
    }
    p->data = e;
    p->next = NULL;
    if (qptr->rear == NULL)
    {
        qptr->rear = p;
        qptr->rear->next = p;
        qptr->length++;
    }
    else
    {
        p->next = qptr->rear->next;
        qptr->rear->next = p;
        qptr->rear = p;
        qptr->length++;
    }
}

void output(Queue* qptr)
{
    node* p;
    p = qptr->rear->next;
    while (p != qptr->rear) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("%d\n", p->data);
}
void pop(Queue* qptr)
{
    if (qptr->rear == NULL)
    {
        //printf("pop:empty queue\n");
        return;
    }
    node* p = qptr->rear->next;//p指向队头节点
    qptr->rear->next = p->next;//队尾节点指针域指向对头结点的下一个
    free(p);
    qptr->length--;
}
int getpop(Queue* qptr)
{
    if (qptr->rear == NULL)
    {
        printf("getpop:empty queue\n");
    }
    else
    {
        return qptr->rear->next->data;
    }
}
int main()
{
    Queue* qptr = create();
    int n, e;
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
    {
        scanf("%d", &e);
        push(qptr, e);
    }
    char s1[5];
    scanf("%s", s1);
    int pope;
    scanf("%d", &pope);
    while (getpop(qptr) != pope)
        pop(qptr);
    pop(qptr);
    output(qptr);
    printf("%d", getpop(qptr));
    free(qptr);
    return 0;
}

#include<iostream>
using namespace std;
typedef struct node {
	int data;
	struct node* next;
}node;
//队列对头和队尾指针 
typedef struct Queue {
	struct node* front;
	struct node* rear;
}Queue;
int isempty(Queue* ptr) {
	if (ptr->front == NULL) {
		return 1;
	}
	return 0;
} 
Queue* create() {//创建空队列
	Queue* ptr = new Queue;
	if (!ptr)
		return NULL;
	else
		ptr->front = ptr->rear = NULL;
	return ptr;
} 
void insert(Queue* ptr, int x) {
	node* p = new node;
	if (p == NULL) {
		cout << "error" << endl;
	}
	else {
		p->data = x;
		p->next = NULL;
		if (isempty(ptr)){
			ptr->front = ptr->rear = p;
			ptr->rear->next = ptr->front;
		}
		else {
			ptr->rear->next = p;
			ptr->rear = p;
			ptr->rear->next = ptr->front;
		}
	}
}
int popQueue(Queue* ptr) {
	node* p;
	int x;
	if (ptr->front == NULL) {
		cout << "Empty queue" << endl;
		return 0;
	}
	else {
		p = ptr->front;
		ptr->front = ptr->front->next;
		ptr->rear->next = ptr->front;
		x = p->data;
		free(p);
		return x;
	}
}
int getfront(Queue* ptr) {
	int x = ptr->front->data;
	return x;
}
void display(Queue* ptr) {
	node* p;
	p = ptr->front;
	while (1) {
		cout << p->data<<" ";
		p = p->next;
		if (p == ptr->front) 
			break;
	}
}
void FibonacciArray(Queue* ptr, int max, int k) {
	for (int i = k; i > 1; i--) {
		insert(ptr, 0);
	}
	insert(ptr, 1);
	//k阶斐波那契数列的初始化：
	//前k-1项都为0，第k项为1
	node* p = ptr->front;
	while (p->next->data == 0) 
		p = p->next;
	while (1) {
		int x = 0;
		node* q = p;
		for (int i = k; i > 0; i--) {
			x += q->data;
			q = q->next;
		}
		if (x > max) 
			break;
		insert(ptr, x);
		p = p->next;
		popQueue(ptr);
	}
}
//完成斐波那契数列的复杂功能 

int main() {
	int max, k;
	cin >> max >> k;
	Queue* ptr = create();
	FibonacciArray(ptr, max, k);
	display(ptr);
	return 0;
}