数据结构-栈和队列

于 2019-07-30 23:02:03 发布
阅读量165 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41433183/article/details/97829642

一、栈的几种操作

#include "stdio.h"

#define STACK_INIT_SIZE 100
#define STACK_INCREMENT 10
#define ElemType int

typedef struct 
{
	ElemType *base;
	ElemType *top;
	int stackSize;
}sqStack;

/****
压栈
*****/

void Push(sqStack *s, ElemType e)
{
	if(s->top - s->base >= s->stackSize)
	{
		s->base = (ElemType *)realloc(s->base, (s->stackSize + STACK_INCREMENT) * sizeof(ElemType));
		if(!s->base)
			exit(0);
		s->top = s->base + s->stackSize;  // 设置栈顶
		s->stackSize = s->stackSize + STACK_INCREMENT; // 设置栈最大容量
	}
	*(s->top) = e;
	s->top++;
}

/****
出栈
*****/

void pop(sqStack *s, ElemType e)
{
	if(s->top == s->base)  // 栈为空
	{
		return;
	}
	*e = *--(s->top);
}

/*********
清空一个栈
**********/

void ClearStack(sqStack *S)
{
	s->top = s->base;
}

/*********
销毁一个栈
**********/

void DestroyStack(sqStack *S)
{
	int i, len;
	len = s->stackSize;
	for(i = 0; i < len; i++)
	{
		free(s->base);
		s->base++;
	}
	s->base = s->top = NULL;
	s->stackSize = 0;
}

/*******************************
计算当前容量(也就是)计算栈中元素
*******************************/

int StackLen(sqStack S)
{
	return (s.top - s.base);
}

完整出入栈代码：

#include "stdio.h"


#define OK 1
#define ERROR 0

typedef int ElemType;
typedef int Status;


typedef struct StackNode
{
	ElemType data;  // 栈放数据
	struct StackNode *next;
}StackNode, *LinkStackPtr;

typedef struct LinkStack
{
	LinkStackPtr top;  // top指针
	int count;  // 栈元素计数器
}LinkStackList;


Status InitStack(LinkStackList *S)
{
	S = (LinkStackList *)malloc(sizeof(LinkStackList));
	// S->top = NULL;
	S->count = 0;
}


Status Push(LinkStackList *s, ElemType e)
{
	LinkStackPtr p;
	p = (LinkStackPtr)malloc(sizeof(StackNode));
	p->data = e;
	p->next = s->top;
	s->top = p;
	s->count++;
	return OK;
}


Status StackEmpty(LinkStackList *s)
{
	if(s->count == 0)
		return 1;
	return 0;
}

Status Pop(LinkStackList *s, ElemType e)
{
	LinkStackPtr p;
	if(StackEmpty(s))
		return ERROR;
	e = s->top->data;
	p = s->top;
	s->top = s->top->next;
	free(p);
	s->count--;
	return OK;
}


int main()
{
	LinkStackList *L;
	ElemType e;
	int i;
	InitStack(&L);
	for ( i = 0; i < 3; i++)
	{
		Push(&L, i);
	}
	printf("\n%d", L->count);
	while (Pop(&L, e))
	{
		printf("%d ", e);
	}
	return 0;
}

二、逆波兰计算器

  1. 中缀表达式转化为后缀表达式

    // 1 + (2 - 3) * 4 + 10 / 5 
#include "stdio.h"
#include "stdlib.h"
#include "ctype.h"

#define STACK_INIT_SIZE 20
#define STACKINCREMENT 20


typedef char ElemType;

typedef struct
{
	ElemType *base;
	ElemType *top;
	int stackSize;
}sqStack;


void InitStack(sqStack *s)
{
	s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
	if(!s->base)
		exit(0);
	s->top = s->base;
	s->stackSize = STACK_INIT_SIZE;
}

void Push(sqStack *s, ElemType e)
{
	if(s->top - s->base >= s->stackSize)
	{
		s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
		if(!s->base)
			exit(0);
	}
	*(s->top) = e;
	s->top++;
}

void Pop(sqStack *s, ElemType *e)
{
	if(s->top == s->base)
		return;
	*e = *--(s->top);
}

int StackLen(sqStack s)
{
	return (s.top - s.base);
}

int main()
{
	sqStack s;
	char c, e;
	InitStack(&s);
	printf("please input math experss, as end with 'enter' : \n");
	scanf("%c", &c);
	while(c != '\n')
	{
		while(c >= '0' && c <= '9')
		{
			printf("%c", c);
			scanf("%c", &c);
			if(c < '0' || c > '9')
			{
				printf(" ");
			}
		}
		if(')' == c)
		{
			Pop(&s, &e);
			while('(' != e)
			{
				printf("%c ", e);
				Pop(&s, &e);
			}
		}
		else if('+' == c || '-' == c)
		{
		 
			if(!StackLen(s))
			{
				Push(&s, c);
			}
			else
			{
				do{
					Pop(&s, &e);
					if('(' == e)
					{
						Push(&s, e);
					}
					else{
						printf("%c ", e);
					}

				}
				while(StackLen(s) && '(' != e); 
				Push(&s, c);
			}
		}
		else if('*' == c || '/' == c || '(' == c)
		{
			Push(&s, c);
		}
		else if('\n' == c)
		{
			break;
		}
		else{
			printf("\n error: output format error \n");
			return -1;
		}
		scanf("%c", &c);
	}
	while (StackLen(s))
	{
		Pop(&s, &e);
		printf("%c ", e);
	}
	return 0;
}

  2. 对后缀表达式进行计算计算

     #include "stdio.h"
 #include "stdlib.h"
 #include "ctype.h"
 
 
 #define STACK_INIT_SIZE 20
 #define STACKINCREMENT  10
 #define MAXBUFFER       10
 
 typedef double ElemType;
 
 typedef struct
 {
 	ElemType *base;
 	ElemType *top;
 	int stackSize;
 }sqStack;
 
 
 void InitStack(sqStack *s)
 {
 	s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
 	if(!s->base)
 		exit(0);
 	s->top = s->base;
 	s->stackSize = STACK_INIT_SIZE;
 }
 
 void Push(sqStack *s, ElemType e)
 {
 	if(s->top - s->base >= s->stackSize)
 	{
 		s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
 		if(!s->base)
 			exit(0);
 	}
 	*(s->top) = e;
 	s->top++;
 }
 
 void Pop(sqStack *s, ElemType *e)
 {
 	if(s->top == s->base)
 		return;
 	*e = *--(s->top);
 }
 
 int StackLen(sqStack s)
 {
 	return (s.top - s.base);
 }
 
 int main()
 {
 	sqStack s;
 	char c;
 	double d, e;
 	char str[MAXBUFFER];
 	int i = 0;
 	InitStack(&s);
 	printf("please input RPN experss split by ' ', '#' as end \n");
 	scanf("%c", &c);
 	while(c != '#')
 	{
 		while(isdigit(c) || c == '.')
 		{
 			str[i++] = c;
 			str[i] = '\0';
 			if(i > 10)
 			{
 				printf("\n error: the num lenth is too long \n");
 				return -1;
 			}
 			scanf("%c", &c);
 			if(c == ' ')
 			{
 				d = atof(str);
 				Push(&s, d);
 				i = 0;
 				break;
 			}
 		}
 		switch(c)
 		{
 			case '+':Pop(&s, &e);Pop(&s, &d);Push(&s, d + e);break;
 			case '-':Pop(&s, &e);Pop(&s, &d);Push(&s, d - e);break;
 			case '*':Pop(&s, &e);Pop(&s, &d);Push(&s, d * e);break;
 			case '/':
 				Pop(&s, &e);
 				Pop(&s, &d);
 				if(e != 0)
 					Push(&s, d / e);
 				else{
 					printf("\n error: chushu is 0 \n");
 					return -1;
 				}
 				break;
 		}
 		scanf("%c", &c);
 	}
 	Pop(&s, &d);
 	printf("the result is %f \n", d);
 	return 0;
 }
 
 
 // 5 - (6 + 7) * 8 + 9 / 4 <===============>  5 6 7 + 8 * - 9 4 / +

三、二进制转换为十进制

#include "stdio.h"
#include "stdlib.h"
#include "math.h"


#define STACK_INIT_SIZE 20
#define STACKINCREMENT 20


typedef char ElemType;
typedef struct
{
	ElemType *base;
	ElemType *top;
	int stackSize;
}sqStack;


void InitStack(sqStack *s)
{
	s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
	if(!s->base)
		exit(0);
	s->top = s->base;
	s->stackSize = STACK_INIT_SIZE;
}

void Push(sqStack *s, ElemType e)
{
	if(s->top - s->base >= s->stackSize)
	{
		s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
		if(!s->base)
			exit(0);
	}
	*(s->top) = e;
	s->top++;
}

void Pop(sqStack *s, ElemType *e)
{
	if(s->top == s->base)
		return;
	*e = *--(s->top);
}

int StackLen(sqStack s)
{
	return (s.top - s.base);
}

int main()
{
	ElemType c;
	sqStack s;
	int len, i, sum = 0;
	InitStack(&s);
	printf("please input bin num, input # quit\n");
	scanf("%c", &c);
	while(c != '#')
	{
		Push(&s, c);
		scanf("%c", &c);
	}
	getchar();  // 把'\n'从缓冲区去掉 
	len = StackLen(s);
	printf("curren lenth: %d\n", len);
	for(i = 0; i < len; i++)
	{
		Pop(&s, &c);
		// if (i>=len)
			// c = '0';
		sum = sum + (c -48) * pow(2, i);
		// if (i%3)
			// sum += (c -48) * pow(2, i%3);
		// else
			// if(i)
				// Push(&r, sum);
			// sum = (c -48) * 1;
		
	}
	// len = StackLen(r);
	// for(i = 0; i < len; i++)
	// {
		// Pop(&r, &d);
		// printf("%d", d);
	// }
	printf("chang result: %d", sum);
	return 0;
}

/****************************************
二进制转八进制
*****************************************/

四、队列

#include "stdio.h"
#include "stdlib.h"



typedef int ElemType;

/*************************************************
链式存储
**************************************************/

typedef struct QNode
{
	ElemType data;
	struct QNode *next;
}QNode, *QueuePrt;


typedef struct
{
	QueuePrt front, rear; // 队头，尾指针
}LinkQueue;

void IniQueue(LinkQueue *q)
{
	q->front=q->rear=(QueuePrt)malloc(sizeof(QNode));
	if(!q->front)
		exit(0);
	q->front->next = NULL;
}

void InsertQueue(LinkQueue *q, ElemType e)
{
	QueuePrt p;
	p = (QueuePrt)malloc(sizeof(QNode));
	if(!p)
		exit(0);
	p->data = e;
	p->next = NULL;
	q->rear->next = p;
	q->rear = p;
}

void DeleteQueue(LinkQueue *q, ElemType *e)
{
	QueuePrt p;
	if(q->front == q->rear)
		exit(0);
	p = q->front->next;
	*e = p->data;
	q->front->next = p->next;
	if(q->rear == p)
		q->rear = q->front;
	free(p);
}

void DestroyQueue(LinkQueue *q)
{
	while(q->front)
	{
		q->rear = q->front->next;
		free(q->front);
		q->front = q->rear;
	}
}

/*************************************************
顺序存储
**************************************************/

#define MAXSIZE 100
typedef struct
{
	ElemType *base;
	int front;
	int rear;
}cycleQueue;

void InitQueue(cycleQueue *q)
{
	q->base = (ElemType *)malloc(MAXSIZE * sizeof(ElemType));
	if(!q->base)
		exit(0);
	q->front = q->rear = 0;
}


void InsertQueue(cycleQueue *q, ElemType e)
{
	if((q->rear + 1) % MAXSIZE == q->front)
		return;  // 队列已满
	q->base[q->rear] = e;
	q->rear = (q->rear + 1 ) % MAXSIZE;
}

void DeleteQueue(cycleQueue *q, ElemType *e)
{
	if(q->rear == q->front)
		return;  // 队列为空
	*e = q->base[q->front];
	q->front = (q->front + 1 ) % MAXSIZE;
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值