实验二 栈和队列

这个作业属于哪个课程	https://edu.cnblogs.com/campus/qdu/DS2020/homework/11296
这个作业要求在哪里	https://edu.cnblogs.com/campus/qdu/DS2020/homework/11296
这个作业的目标	掌握栈的结构特性及其入栈，出栈操作。掌握队列的结构特性及其入队、出队的操作，掌握循环队列的特点及其操作。
学号	2018204179
一、实验目的
1、掌握栈的结构特性及其入栈，出栈操作；
2、掌握队列的结构特性及其入队、出队的操作，掌握循环队列的特点及其操作。

二、实验预习
说明以下概念
1、顺序栈：
顺序栈是栈的顺序实现。顺序栈是指利用顺序存储结构实现的栈。采用地址连续的存储空间（数组)依次存储栈中数据元素，由于入栈和出栈运算都是在栈顶进行，而栈底位置是固定不变的，可以将栈底位置设置在数组空间的起始处；栈顶位置是随入栈和出栈操作而变化的，故需用一个整型变量top来记录当前栈顶元素在数组中的位置。
2、链栈：
链式栈是一种数据存储结构，可以通过单链表的方式来实现，使用链式栈的优点在于它能够克服用数组实现的顺序栈空间利用率不高的特点，但是需要为每个栈元素分配额外的指针空间用来存放指针域。
3、循环队列：
为充分利用向量空间，克服"假溢出"现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列（Circular Queue）。循环队列是把顺序队列首尾相连，把存储队列元素的表从逻辑上看成一个环，成为循环队列。
4、链队
使用链表实现的队列；具有队头指针和队尾指针，指示队列元素所在的位置。
三、实验内容和要求
1、阅读下面程序，将函数Push和函数Pop补充完整。要求输入元素序列1 2 3 4 5 e，运行结果如下所示。

#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define OK 1
#define STACK_INT_SIZE 10  /*存储空间初始分配量*/
#define STACKINCREMENT 5  /*存储空间分配增量*/
typedef  int ElemType; /*定义元素的类型*/
typedef struct{
    ElemType *base;
    ElemType *top;
    int stacksize;     /*当前已分配的存储空间*/
}SqStack;

int InitStack(SqStack *S);   /*构造空栈*/
int push(SqStack *S,ElemType e); /*入栈*/
int Pop(SqStack *S,ElemType *e);  /*出栈*/
int CreateStack(SqStack *S);     /*创建栈*/
void PrintStack(SqStack *S);   /*出栈并输出栈中元素*/

int InitStack(SqStack *S){
    S->base=(ElemType *)malloc(STACK_INT_SIZE *sizeof(ElemType));
    if(!S->base) return ERROR;
    S->top=S->base;
    S->stacksize=STACK_INT_SIZE;
    return OK;
}/*InitStack*/

int Push(SqStack *S,ElemType e){
    if(S->top-S->base==S->stacksize)
	{
		int i=S->stacksize-1;
		ElemType *pt;
		pt=(ElemType *)malloc(2*S->stacksize*sizeof(ElemType));
		while(i>=0)
		{
			*(pt+i)=*(S->base+i);
			i--;
		}
		free(S->base);
		S->base=pt;
		S->top=pt+S->stacksize;
		S->stacksize*=2;
	}
	*(S->top)=e;
	S->top++;
	return OK;
}/*Push*/

int Pop(SqStack *S,ElemType *e){
   if(S->top>S->base)
	{
		S->top--;
		*e=*(S->top);
		return OK;
	}
	else
	{
		free(S->base);
		return ERROR;
	}
}/*Pop*/

int CreateStack(SqStack *S){
    int e;
    if(InitStack(S))
        printf("Init Success!\n");
    else{
        printf("Init Fail!\n");
        return ERROR;
    }
    printf("input data:(Terminated by inputing a character)\n");
    while(scanf("%d",&e))
        Push(S,e);
    return OK;
}/*CreateStack*/

void PrintStack(SqStack *S){
    ElemType e;
    while(Pop(S,&e))
        printf("%3d",e);
}/*Pop_and_Print*/

int main(){
    SqStack ss;
    printf("\n1-createStack\n");
    CreateStack(&ss);
    printf("\n2-Pop&Print\n");
    PrintStack(&ss);
    return 0;
}

• 算法分析：输入元素序列1 2 3 4 5，为什么输出序列为5 4 3 2 1？体现了栈的什么特性？
  按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。
  先进后出，元素逆序输出。

2、在第1题的程序中，编写一个十进制转换为二进制的数制转换算法函数（要求利用栈来实现），并验证其正确性。

• 实现代码

void conveshen(SqStack *S) {
	ElemType n,h; 
	int m=0,k=0; 
	InitStack(S); 
	printf("Input element\n"); 
	scanf("%d",&n);  
	while(n) { 
		m++; 
    	Push(S,n%2); 
    	n=n/2; 
	} 
	while(k<m) {    
		k++; 
		Pop(S,&h); 
		printf("%d",h); 
	}
} 
int main() {    
	SqStack S; 
    conveshen(&S); 
	printf("\n");  
	return 0;
}

• 验证
  Input element
  13
  1101
  
  3、阅读并运行程序，并分析程序功能。

#include<stdio.h>
#include<malloc.h>
#include<string.h>
#define M 20
#define  elemtype  char
typedef struct
{
    elemtype stack[M];
    int top;
}
stacknode;
void init(stacknode *st);
void push(stacknode *st,elemtype x);
void pop(stacknode *st);

void init(stacknode *st)
{
    st->top=0;
}

void push(stacknode *st,elemtype x)
{
    if(st->top==M)
        printf("the stack is overflow!\n");
    else
    {
        st->top=st->top+1;
        st->stack[st->top]=x;
    }
}

void pop(stacknode *st)
{
if(st->top>0)  st->top--;
    else  printf(“Stack is Empty!\n”);
}

int main()
{
    char s[M];
    int i;
    stacknode *sp;
    printf("create a empty stack!\n");
    sp= (stacknode*)malloc(sizeof(stacknode));
    init(sp);
    printf("input a expression:\n");
    gets(s);
    for(i=0;i<strlen(s);i++)
    {
        if(s[i]=='(')
            push(sp,s[i]);
        if(s[i]==')')
            pop(sp);
    }
    if(sp->top==0)
        printf("'('match')'!\n");
    else
        printf("'('not match')'!\n");
    return 0;
}

输入：2+((c-d)6-(f-7)a)/6
运行结果：'('match')'!
输入：a-((c-d)*6-(s/3-x)/2
运行结果：'('not match')'!

• 程序的基本功能：
  判断多项式的左右括号是否配对

以下为选做实验：
4、设计算法，将一个表达式转换为后缀表达式，并按照后缀表达式进行计算，得出表达式得结果。

• 实现代码

//中缀表达式转后缀
#include<iostream>
#include<string>
#include<stack>
using namespace std;

int prio(char op) {                 //给运算符优先级排序
	int priority;
	if (op == '*' || op == '/')
		priority = 2;
	if (op == '+' || op == '-')
		priority = 1;
	if (op == '(')
		priority = 0;
	return priority;
}
bool Trans(string &str,string &str1) {   //引用传递
	stack<char> s;                   //定义一个char类型的栈s
	int i;
	for (i = 0; i<str.size(); i++) {
		if (str[i] >= '0' && str[i] <= '9') {    //如果是数字，直接入栈
			str1+=str[i];
		}
		else {                        //否则不是数字
			if (s.empty())            //栈空则入站
				s.push(str[i]);
			else if (str[i] == '(')   //左括号入栈
				s.push(str[i]);
			else if (str[i] == ')') {  //如果是右括号，只要栈顶不是左括号，就弹出并输出
				while (s.top() != '(') {  
					str1+= s.top();
					s.pop();
				}
				s.pop();                 //弹出左括号，但不输出
			}
			else {
				while (prio(str[i]) <= prio(s.top())) { //栈顶优先级大于等于当前运算符，则输出
					str1+= s.top();
					s.pop();
					if (s.empty())      //栈为空，停止
						break;
				}
				s.push(str[i]);   //把当前运算符入栈
			}
		}
	}
	while (!s.empty()) {      //最后，如果栈不空，则弹出所有元素并输出
		str1+= s.top();
		s.pop();
	}
	return true;
}
int main() {                //主程序
	string infix;
	string postfix;
	cout << "请输入中缀表达式：" << infix << endl;
	cin >> infix;
	Trans(infix,postfix);
	cout << "后缀表达式为：" << postfix << endl;
	return 1;
}

5、假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾结点（不设队头指针），试编写相应的置空队列、入队列、出队列的算法。
实现代码：

/*  数据结构算法题(假设以带头结点的循环链表表示队列,
 *  并且只设一个指针指向队尾元素结点(注意不设头指针)
 *  试编写相应的队列初始化,入队列和出队列的算法!) 
 */
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define OK 1
#define ERROR 0

typedef int QElemType;
typedef int Status;

typedef struct QNode
{
    QElemType data;
    struct QNode * rear;
    struct QNode * next;
}QNode,*LinkQueue;


//链式队列的初始化
Status InitLinkQueue(LinkQueue * L)
{

    (*L)=(LinkQueue)malloc(sizeof(QNode));
    if((*L)==NULL)
    {
        printf("内存分配失败！\n");
        return OK;
    }
    (*L)->rear=(*L);
    return OK;
}

//链式队列的建立
Status Create(LinkQueue * L,int n)
{
    srand(time(0));
    LinkQueue P;
    for(int i=0;i<n;i++)
    {
        P=(LinkQueue)malloc(sizeof(QNode));
        P->data=rand()%100+1;
        (*L)->rear->next=P;
        (*L)->rear=P;
    }
    P->next=(*L);
    return OK;
}

//入队操作
Status EnQueue(LinkQueue * L,QElemType e)
{
    LinkQueue P;
    P=(LinkQueue)malloc(sizeof(QNode));
    P->data=e;
    P->next=(*L);
    (*L)->rear->next=P;
    (*L)->rear=P;
    return OK;
}


//出队操作
Status DeQueue(LinkQueue * L,QElemType * e)
{
    LinkQueue temp;
    *e=(*L)->next->data;
    temp=(*L)->next;
    (*L)->next=(*L)->next->next;
    delete(temp);
    return OK;

}

//输出
void Print(LinkQueue * L)
{
    LinkQueue P;
    P=(*L)->next;
    printf("输出元素:\n");
    while(P!=(*L))
    {
        printf("%d ",P->data);
        P=P->next;
    }
    printf("\n");
}


int main()
{
    LinkQueue L;
    int ElemNumber;
    QElemType EnElem,DeElem;
    InitLinkQueue(&L);
    printf("请输入元素个数：\n");
    scanf("%d",&ElemNumber);
    Create(&L,ElemNumber);
    Print(&L);
    printf("请输入入队元素：\n");
    scanf("%d",&EnElem);
    EnQueue(&L,EnElem);
    Print(&L);
    printf("出队操作，并返回出队元素：\n");
    DeQueue(&L,&DeElem);
    printf("出队元素为：%d\n",DeElem);
    Print(&L);
    return 0;
}

四、实验小结
掌握栈的结构特性及其入栈，出栈操作。掌握队列的结构特性及其入队、出队的操作，掌握循环队列的特点及其操作。