栈和队列

最新推荐文章于 2019-08-27 23:02:16 发布
最新推荐文章于 2019-08-27 23:02:16 发布
阅读量106 收藏
点赞数
分类专栏： 代码练习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lc578626/article/details/99727791
版权 
#pragma once

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<windows.h>

typedef int DataType;

//typedef char DataType;

//动态顺序栈
typedef struct Stack
{
	DataType* _arr;
	size_t _top;  //栈顶 -> 只可以在这一段进行插入和删除
	size_t _end;  //栈底
}Stack;

void StackInit(Stack *s);
void StackPush(Stack *s, DataType data);
void StackPop(Stack *s);
DataType StackTop(Stack *s);
void StackPrint(Stack *s);
int EmptyStack(Stack *s);
void StackSize(Stack *s);

///栈的应用/

//括号匹配问题
void MatchBrackets(char *buf, int len);
//逆波兰表达式
int ExpressionRPN(char *rpn, int len);
//寻找空格
int FindSpace(char *rpn, int pos, int len);

#include"Stack.h"

void StackInit(Stack *s)
{
	assert(s);
	s->_arr = NULL;
	s->_end = s->_top = 0;
}

void StackPush(Stack *s, DataType data)
{
	assert(s);
	if (s->_end == s->_top)
	{
		size_t size = s->_end > 0 ? 2 * s->_end : 3;
		s->_arr = (DataType*)realloc(s->_arr, sizeof(DataType) * size);
		assert(s->_arr);
		s->_end = size;
	}
	s->_arr[s->_top++] = data;
}

void StackPop(Stack *s)
{
	assert(s);
	if(s->_top)
		--s->_top;
}

DataType StackTop(Stack *s)
{
	assert(s);
	
	return s->_arr[s->_top - 1];
}

void StackPrint(Stack *s)
{
	size_t i = 0;
	assert(s);
	if (s->_top != 0)
	{
		for (i = 0; i < s->_top; ++i)
			printf("%d ", s->_arr[i]);

		printf("\n");
	}
	else
	{
		printf("栈为空\n");
	}
}

int EmptyStack(Stack *s)
{
	assert(s);
	//if (0 == s->_top)
	//	return 0;

	//return 1;

	return s->_top;

}

void StackSize(Stack *s)
{
	assert(s);

	printf("栈内数据个数为：%u \n", s->_top);
}

///栈的应用/

//括号匹配问题
void MatchBrackets(char *buf, int len)
{
	Stack s;
	StackInit(&s);
	int i = 0;
	assert(buf);
	for (i = 0; i < len; i++)
	{
		//如果是左括号，则将左括号入栈
		if (('(' == buf[i]) ||
			('[' == buf[i]) ||
			('{' == buf[i]))
		{
			StackPush(&s, buf[i]);
		}

		//如果是右括号，则与栈顶元素比较，如果匹配，则出栈进行下轮
		//若不匹配则直接退出
		if ((')' == buf[i]) ||
			(']' == buf[i]) ||
			('}' == buf[i]))
		{
			if (0 == EmptyStack(&s))
			{
				printf("不匹配，右括号多于左括号\n");
				return;
			}
			else
			{
				switch (buf[i])
				{
				case ')':
					if ('(' == StackTop(&s))
					{
						StackPop(&s);
						break;
					}
					else
					{
						printf("不匹配,左右括号次序不匹配\n");
						return;
					}

				case ']':
					if ('[' == StackTop(&s))
					{
						StackPop(&s);
						break;
					}
					else
					{
						printf("不匹配,左右括号次序不匹配\n");
						return;
					}

				case '}':
					if ('{' == StackTop(&s))
					{
						StackPop(&s);
						break;
					}
					else
					{
						printf("不匹配,左右括号次序不匹配\n");
						return;
					}

				default:
					return;
				}
			}
		}

	}

	//判断栈是否为空
	if (0 == EmptyStack(&s))
	{
		//若栈为空则匹配
		printf("括号匹配\n");
		return;

	}

	//栈不为空
	printf("不匹配，左括号多于右括号\n");
	return;
}



//寻找空格
int FindSpace(char *rpn, int pos, int len)
{
	for (; pos < len; ++pos)
	{
		if (' ' == rpn[pos])
			return pos;
	}

	return -1;
}
//逆波兰表达式
int ExpressionRPN(char *rpn, int len)
{
	int i = 0;
	//int num = 0;
	int rightnum = 0;
	int leftnum = 0;
	Stack s;
	StackInit(&s);
	assert(rpn);

	for (i = 0; i < len; ++i)
	{
		if (rpn[i] >= '0' && rpn[i] <= '9')
		{
			StackPush(&s, atoi(&rpn[i]));
			i = FindSpace(rpn, i, len);
			//continue;
		}
		if (('+' == rpn[i]) || ('-' == rpn[i]) || ('*' == rpn[i]) || ('/' == rpn[i]))
		{
			switch (rpn[i])
			{
			case '+':
				//先取右操作数,再出栈
				rightnum = StackTop(&s);
				StackPop(&s);
				//再取左操作数，再出栈
				leftnum = StackTop(&s);
				StackPop(&s);
				//将计算结果入栈
				StackPush(&s, leftnum + rightnum);
				break;

			case '-':
				//先取右操作数,再出栈
				rightnum = StackTop(&s);
				StackPop(&s);
				//再取左操作数，再出栈
				leftnum = StackTop(&s);
				StackPop(&s);
				//将计算结果入栈
				StackPush(&s, leftnum - rightnum);
				break;

			case '*':
				//先取右操作数,再出栈
				rightnum = StackTop(&s);
				StackPop(&s);
				//再取左操作数，再出栈
				leftnum = StackTop(&s);
				StackPop(&s);
				//将计算结果入栈
				StackPush(&s, leftnum * rightnum);
				break;

			case '/':
				//先取右操作数,再出栈
				rightnum = StackTop(&s);
				StackPop(&s);
				//再取左操作数，再出栈
				leftnum = StackTop(&s);
				StackPop(&s);
				//将计算结果入栈
				StackPush(&s, leftnum / rightnum);
				break;

			default:
				break;
			}
		}
	}

	//计算完毕，结果在栈里
	return StackTop(&s);
}

#pragma once

#include<stdio.h>
#include<assert.h>
#include<malloc.h>
#include<windows.h>

typedef char DataType;

//链式队列
typedef struct QueueNode
{
	DataType _data;
	struct QueueNode* _next;

}QueueNode;

typedef struct Queue
{
	QueueNode* _head;
	QueueNode* _tail;

}Queue;

QueueNode* BuyQueueNode(DataType data); //创建一个节点
void QueueInit(Queue* q); //初始化
void QueuePush(Queue* q, DataType data); //入队
void QueuePop(Queue* q); //出队
DataType QueueFront(Queue* q); //取队头
DataType QueueBack(Queue* q); //取队尾
void QueuePrint(Queue* q); //打印队列
void QueueSize(Queue* q); //求队列中的数据个数
int EmptyQueue(Queue* q); //判断队列是否为空

#include"Queue.h"

QueueNode* BuyQueueNode(DataType data) //创建一个节点
{
	QueueNode *newnode = NULL;
	newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (NULL == newnode)
	{
		printf("创建节点失败\n");
		return NULL;
		assert(newnode);
	}
	else
	{
		newnode->_data = data;
		newnode->_next = NULL;
		return newnode;
	}

}


void QueueInit(Queue* q) //初始化
{
	assert(q);

	q->_head = q->_tail = NULL;
}

void QueuePush(Queue* q, DataType data) //入队
{
	QueueNode *newnode = NULL;
	assert(q);

	newnode = BuyQueueNode(data);

	if (NULL == q->_head)     //如果队列为空
		q->_head = q->_tail = newnode;

	else
	{
		q->_tail->_next = newnode;  //先将新节点和队列连接起来
		q->_tail = newnode;         //将队列的尾更新
	}
}

void QueuePop(Queue* q) //出对
{
	QueueNode *del = NULL;
	assert(q);

	del = q->_head;
	q->_head = q->_head->_next;
	free(del);
}

DataType QueueFront(Queue* q) //取队头
{
	assert(q);
	//默认是有队列中是有数据的
	return q->_head->_data;
}

DataType QueueBack(Queue* q) //取队尾
{
	assert(q);
	//默认是有队列中是有数据的
	return q->_tail->_data;
}

void QueuePrint(Queue* q) //打印队列
{
	QueueNode *cur = NULL;
	assert(q);
	cur = q->_head;
	while (cur)
	{
		printf("%d ", cur->_data);
		cur = cur->_next;
	}
	printf("\n");
}

void QueueSize(Queue* q) //求队列中的数据个数
{	
	QueueNode *cur = NULL;
	int count = 0;
	assert(q);
	
	cur = q->_head;
	while (cur)
	{
		++count;
		cur = cur->_next;
	}
	printf("队列中的数据个数为：%d \n", count);
}

int EmptyQueue(Queue* q)//判断队列是否为空
{
	assert(q);

	if (NULL == q->_head)  //队列空返回0
		return 0;
	
	return 1;
}

#include"Queue.h"
#include"Stack.h"

//队列的测试///

//test()
//{
//	Queue q;
//	QueueInit(&q);
//
//	QueuePush(&q, 1);
//	QueuePush(&q, 2);
//	QueuePush(&q, 3);
//	QueuePush(&q, 4);
//	QueuePush(&q, 5);
//
//	QueueSize(&q);
//
//	QueuePrint(&q);
//
//	printf("队头为：%d \n", QueueFront(&q));
//	printf("队尾为：%d \n", QueueBack(&q));
//
//	QueuePop(&q);
//	QueuePop(&q);
//	QueuePop(&q);
//	QueuePop(&q);
//	//QueuePop(&q);
//
//	QueueSize(&q);
//
//	QueuePrint(&q);
//
//	printf("队头为：%d \n", QueueFront(&q));
//	printf("队尾为：%d \n", QueueBack(&q));
//
//}
//
//int main()
//{
//	test();
//
//	system("pause");
//	return 0;
//}

栈的测试//

//test()
//{
//	Stack s;
//	StackInit(&s);
//	StackPush(&s, 1);
//	StackPush(&s, 2);
//	StackPush(&s, 3);
//	StackPush(&s, 4);
//	StackPush(&s, 5);
//	StackPush(&s, 6);
//
//	StackSize(&s);
//	StackPrint(&s);
//	printf("%d \n",StackTop(&s));
//	//StackPop(&s);
//	StackPop(&s);
//	StackPop(&s);
//	StackPop(&s);
//	StackPop(&s);
//
//	StackSize(&s);
//
//	//StackPop(&s);
//	StackPrint(&s);
//}
//
//int main()
//{
//	test();
//
//	system("pause");
//	return 0;
//}

栈的应用测试///

测试括号匹配问题
//test1()
//{
//	char buf1[] = "(())abc{[(])}";  //左右括号次序不匹配
//	char buf2[] = "(()))abc{[]}";   //右括号多于左括号
//	char buf3[] = "(()()abc{[]}";   //左括号多于右括号
//	char buf4[] = "(())abc{[]()}";  //匹配正确
//
//	MatchBrackets(buf1, strlen(buf1));
//	MatchBrackets(buf2, strlen(buf2));
//	MatchBrackets(buf3, strlen(buf3));
//	MatchBrackets(buf4, strlen(buf4));
//}
//

//测试逆波兰表达式
test2()
{
	char rpn[] = "12 3 4 + * 6 - 8 2 / +";
	
	int ret = ExpressionRPN(rpn, strlen(rpn));
	printf("表达式结果为：%d\n", ret);
}


int main()
{
	//test1();
	test2();

	//char c[] = "12 3 4";
	//printf("%d\n", atoi(&c));

	system("pause");
	return 0;
}
会跑路的300块
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构栈和队列试题及答案
11-26
队列和栈都是运算受限的线性表，只允许在表的一端进行特定的插入和删除操作，该说法正确。 18. **栈和队列的基本属性** 栈和队列都是线性表，但它们分别采用了LIFO和FIFO的规则来约束插入和删除操作，该说法正确...
Java基础—assert断言（一）
weixin_44761910的博客
01-28 1171
整理自： java assert断言的用法 java断言机制 java断言机制（assert） Java核心技术 卷I 一、何为断言 断言机制：允许java开发者在代码中加入一些检查语句，主要用于程序调试目的。 1.断言机制在用户定义的boolean表达式结果为false时抛出一个error对象，其类型为AssertionError； 2.当我们需要在约定的条件不成立时中断当前操作的话，可以使用断...
排序算法—堆排序、索引堆（四）
xiaoxin0630的博客
03-05 164
最大堆排序 堆 看数据机构 MaxHeap.java package com.binglian.Heap; import java.util.*; import java.lang.*; // 在堆的有关操作中，需要比较堆中元素的大小，所以Item需要extends Comparable public class MaxHeap&lt;Item extends Comparable&gt...
字符串库函数的模拟实现
weixin_45511964的博客
08-27 124
1.strcpy（字符串拷贝） strcpy(arr,str):arr是要拷贝的空间，str是要被拷贝的字符串。 #include <stdio.h> #include <assert.h> char* my_strcpy(char*dest,const char*str) { char* ret = dest;//保存dest初始位置 assert(dest&...
利用栈和队列实现迷宫
06-20
"利用栈和队列实现迷宫" 通过栈和队列两种不同的方法来实现迷宫问题。队列方法求出的迷宫路径是最短路径。迷宫问题是指在一个迷宫中找到从起点到终点的路径。这里我们使用栈和队列两种数据结构来解决这个问题。 栈...
zhanheduilie.rar_栈和队列
09-24
栈和队列是计算机科学中基础且重要的数据结构，它们在程序设计中有着广泛的应用。在本资料"zhanheduilie.ppt"中，详细讲述了这两种数据结构的原理、特性以及实际应用。 栈（Stack）是一种后进先出（LIFO, Last In ...
Python实现栈和队列的简单操作方法示例
09-18
本篇文章将深入探讨Python中如何实现栈（Stack）和队列（Queue）这两种基础数据结构。 栈是一种后进先出（Last In, First Out, LIFO）的数据结构，常用于临时存储和快速访问数据。在Python中，由于列表（List）的...
栈和队列笔记包括栈和队列的定义、顺序栈出入栈、链栈的出入栈操作、顺序队列基本操作、链式队列基本操作等
最新发布
04-03
### 栈和队列知识点详解 #### 一、栈的定义 栈是一种特殊的线性数据结构，其特点是只允许在一端进行数据的插入和删除操作，遵循“先进后出”(First In Last Out, FILO)的原则。在这个数据结构中，最新加入的数据...
C语言练习题二
lc578626的博客
08-19 1872
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdio.h> ////使用宏实现两个数中求较大值 //#define MAX(a,b) (a)>(b)?(a):(b) // //int main() //{ // int max = MAX(3,4); // printf("max = ...
静态哈希
lc578626的博客
05-13 667
本文哈希函数为：除留余数法。 本文哈希冲突的处理方法： 闭散列：也叫开放地址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到表中 “下一个” 空位中去 。 二次探测：二次探查法在表中寻找“下一个”空位置的公式为：Hi+1 = Hi + (i + 1)^2，Hi =H0 + i^2 。化简后为Hi+1 = i * 2 + 1。 HashTabl...
日期类（c++实现）
lc578626的博客
03-30 334
Date.h #pragma once #include&lt;iostream&gt; using namespace std; class Date { public: //构造函数 Date(int year = 1900, int month = 1, int day = 1) //:_year(year) //初始化列表 //...
C/C++动态内存管理
lc578626的博客
04-26 333
#include<iostream> using namespace std; //1.C语言中的动态内存管理 //malloc/calloc/realloc/free #if 0 #include<stdlib.h> int main() { int* p1 = (int*)malloc(sizeof(int)); free(p1); //malloc/ca...
栈的应用——括号匹配
lc578626的博客
04-20 287
//括号匹配问题 void MatchBrackets(char *buf, int len) { Stack s; StackInit(&amp;s); int i = 0; assert(buf); for (i = 0; i &lt; len; i++) { //如果是左括号，则将左括号入栈 if (('(' =...
三子棋
lc578626的博客
10-26 278
#ifndef __GAME_H__ #define __GAME_H__ void game(); void CheckerBoard(char arr[3][3]); void PrintArr(char arr[3][3]); void Computer(char arr[3][3]); void Player(char arr[3][3]); void IsWin(char arr[3][3
有关操作单链表的函数
lc578626的博客
12-15 237
slist.h#ifndef __SLIST_H__ #define __SLIST_H__#include<stdio.h> #include<assert.h> #include<stdlib.h>typedef int DataType;typedef struct SListNode { struct SListNode *_next; DataType _data; }SL
C语言练习三
lc578626的博客
08-19 235
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> ////100-200素数 //int main() //{ // int i; // int k; // int count=0; // for(i=100;i<=200;i++) // { // for(k=2;k<i;k++) // { //...
无头单链表的操作（基于前面的修改版）
lc578626的博客
03-27 225
slist.h #pragma once #define _CRT_SECURE_NO_WARNINGS 1 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;assert.h&gt; typedef int DataType; typedef struct SlistNode { struct Slist...
C语言练习题一
lc578626的博客
08-19 227
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> //求n! //int main() //{ // int i = 0; // int j = 0; // int ret=1; // scanf("%d",&j); // for(i=1;i<=j;i++) // { // ret=ret*i; // } // p...
c语言练习题二：
lc578626的博客
04-22 192
1.//递归和非递归分别实现求第n个斐波那契数 //递归的方法 int Fib(int n) { if(n&lt;=2) { return 1; } else { return Fib(n-1)+Fib(n-2); } ...
栈和队列基础与实现
"本资源是关于课堂练习，主要涉及栈和队列这两种数据结构，特别是循环队列的入队和出队算法。同时，提供了链式队列的定义以及栈...通过链式队列和顺序栈的示例，学生可以深入理解这两种数据结构的工作原理和实现细节。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值