DS博客作业02--栈和队列

0.PTA得分截图

1.本周学习总结

1.1总结栈和队列内容

• 栈的存储结构及操作
  • 栈的顺序存储结构

typedef struct
{
        ElemType data[MaxSize]；
        int top；		//栈顶指针
}  Stack；
typedef Stack *SqStack;

• 顺序栈的四要素
  
  栈空条件：top=-1
  
  栈满条件: top=MaxSize-1;
  
  进栈e操作:top++;st->data[top]=e;
  
  退栈操作:e=st->data[top];top--;

• 顺序栈操作

  • 初始化栈

void InitStack(&s)
{
        s=new Stack;
         s->top=-1;
}

  * 销毁栈

void  DestroyStack(SqStack &s)
{
　　delete s;
}

  * 判断栈是否为空

bool StackEmpty(SqStack s)
{
　　return(s->top==-1);
}

  * 进栈

bool Push(SqStack &s，ElemType e)
{
      if (s->top==MaxSize-1) 	//栈满的情况，即栈上溢出
	return false;
      s->top++;		   	//栈顶指针增1
      s->data[s->top]=e;	   	//元素e放在栈顶指针处
      return true;
}

  * 出栈

bool Pop(SqStack &s，ElemType &e)
{
      if (s->top==-1)	//栈为空的情况，即栈下溢出
	return false;
      e=s->data[s->top];	//取栈顶指针元素的元素
      s->top--;		//栈顶指针减1
      return true;
}

  * 取栈顶元素

bool Pop(SqStack &s，ElemType &e)
{    if (s->top==-1)	//栈为空的情况，即栈下溢出
	return false;
      e=s->data[s->top];	//取栈顶指针元素的元素
      s->top--;		//栈顶指针减1
      return true;
}

• 栈的链式存储结构

typedef struct linknode
{
      ElemType data;		//数据域
      struct linknode *next;	//指针域
}  LiNode,*LiStack;

• 链栈的四要素
  
  栈空条件：s->next=NULL
  
  栈满条件：不考虑
  
  进栈e操作：将包含e的结点插入到头结点之后
  
  退栈操作：取出头结点之后结点的元素并删除之
• 链栈的操作
  • 初始化栈

void (LinkStNode *&s)
{
        s= new LiNode;
        s->next=NULL;
}

  * 销毁栈

void DestroyStack(LiStack &s)
{　
    LiStack p=s，q=s->next;
      while (q!=NULL)
      {	free(p);
	p=q;
	q=p->next;
      }
      delete p;	//此时p指向尾结点，释放其空间
}

  * 判断栈空

bool StackEmpty(LiStack s)
{
       return(s->next==NULL);
}

  * 进栈

void Push(LiStack &s，ElemType e)
{
       LiStack p;
       p=new LiNode;
       p->data=e;		//新建元素e对应的结点*p
       p->next=s->next;	//插入*p结点作为开始结点
       s->next=p;
}

  * 出栈

bool Pop(LiStack &s，ElemType &e)
{
      LiStack p;
      if (s->next==NULL)		//栈空的情况
	return false;
      p=s->next;			//p指向开始结点
      e=p->data;
      s->next=p->next;		//删除*p结点
      delete p;			//释放*p结点
      return true;
}

  * 取栈顶元素

bool GetTop(LiStack s，ElemType &e)
{
        if (s->next==NULL)	//栈空的情况
	return false;
       e=s->next->data;
       return true;
}

• 栈的应用
  • 表达式求值
    
    

while （读取字符ch且ch!='\0')
{

       若ch为数字：将后续的所有数字依次存放到postexp中，
       若ch为左括号'('：将此括号进栈;
        ch为右括号')'：出栈时遇到的第一个左括号'('以前的运算符依次出栈并存放到postexp中，然后将左括号'('出栈;
       ch为其他运算符：
	if （栈空或者栈顶运算符为'('） 直接将ch进栈;
	else if (ch的优先级高于栈顶运算符的优先级)
	     直接将ch进栈;
	else
	       依次出栈存入到postexp中，直到栈顶运算符优先级小于ch的优先级，然后将ch进栈;
}
若exp扫描完毕，则将栈中所有运算符依次出栈并存放到postexp中。

• 顺序队
  • 存储结构

typedef struct
{
      ElemType data[MaxSize]；
      int front,rear；      //队首和队尾指针
}   SqQueue,*SqQ;

• 四要素

 队空条件：front = rear
 队满条件：rear = MaxSize－1
 元素e进队：rear++; data[rear]=e;
 元素e出队：front++; e=data[front];

• 初始化队列

void InitQueue(SqQ &q)
{　
      q=new SqQueue;
　    q->front=q->rear=-1;
}

• 销毁队列

void DestroyQueue(SqQ &q)
{
       delete q
}

• 判断队空

bool QueueEmpty(SqQ *q)
{
       return(q->front==q->rear);
}

• 进队

bool enQueue(SqQ &q,ElemType e)
{        

        if (q->rear==MaxSize-1)	//队满上溢出
	  return false;
         q->rear++;
         q->data[q->rear]=e;
         return true;
}

• 出队

bool deQueue(SqQ &q,ElemType &e)
{
        if (q->front==q->rear)　　//队空下溢出
	return false;
       q->front++;
       e=q->data[q->front];
       return true;
}

• 环形队列
  • 四要素

 队空条件：front = rear
 队满条件：(rear+1)%MaxSize = front
 进队e操作：rear=(rear+1)%MaxSize;  将e放在rear处
 出队操作：front=(front+1)%MaxSize; 取出front处元素e;

• 存储结构

typedef struct
{
        ElemType data[MaxSize];
        int front;		//队头指针
        int count;		//队列中元素个数
}  QuType，*Qu;

• 初始化队列

void  InitQueue(Qu &qu)	//初始化队运算算法
{
       qu=new Qutype;
       qu->front=0;
       qu->count=0;
}

• 进队

bool EnQueue(Qu &qu,ElemType x)   //进队运算算法
{
       int rear;		      	  //临时队尾指针
       if (qu->count==MaxSize)	  //队满上溢出
	return false;
       else
       {
        rear=(qu->front+qu->count)%MaxSize;	//求队尾位置
	rear=(rear+1)%MaxSize;  //队尾循环增1
	qu->data[rear]=x;
	qu->count++;		   //元素个数增1
	return true;
      }
}

• 出队

bool DeQueue(Qu &qu,ElemType &x)  	//出队运算算法
{      if (qu->count==0)		         		//队空下溢出
	return false;
       else
       {
            qu->front=(qu->front+1)%MaxSize; 	//队头循环增1
	    x=qu->data[qu->front];
	    qu->count--;			  	 //元素个数减1
	    return true;
       }
}

• 判空

bool QueueEmpty(Qu &qu)	   //判队空运算算法
{
       return(qu->count==0);
}

• 链队
  
  
  
  
  
  

  • 存储结构

typedef struct
{
        elemtype data;
        DataNode *front;	//指向单链表队头结点
        DataNode *rear; 	//指向单链表队尾结点
}  LinkQuNode, *LinkQ;

• 四要素

 队空条件：front=rear=NULL
 队满条件：不考虑
 进队e操作：将包含e的结点插入到单链表表尾
 出队操作：删除单链表首数据结点

• 初始化

void InitQueue(LinkQ &q)
{
        q= new LinkQuNode;
       q->front=q->rear=NULL;
}

• 销毁队列

void DestroyQueue(LinkQ &q)
{
        LinkQ p=q->front，r;  	//p指向队头数据结点
        if  (p!=NULL)		//释放数据结点占用空间
        {      r=p->next;
	while (r!=NULL)
	{      free(p);
	       p=r;r=p->next;
	}
       }
       delete p;
       delete q;		 //释放链队结点占用空间
}

• 判空

bool QueueEmpty(LinkQ q)
{
　　return(q->rear==NULL);
}

• 进队

void enQueue(LinkQ &q，ElemType e)
{
       LinkQ p;
       p=new LinkQuNode;
       p->data=e;
       p->next=NULL;
       if (q->rear==NULL)   //若链队为空，新结点是队首结点又是队尾结点
            q->front=q->rear=p;
      else
      {
        q->rear->next=p;   //将*p结点链到队尾，并将rear指向它
	q->rear=p;
      }
}

• 出队

bool deQueue(LinkQ &q，ElemType &e)
{
      LinkQ t;
      if (q->rear==NULL)
            return false;	//队列为空
      t=q->front;		   		//t指向第一个数据结点
      if (q->front==q->rear)  		//队列中只有一个结点时
	q->front=q->rear=NULL;
      else			   		//队列中有多个结点时
	q->front=q->front->next;
      e=t->data;
      delete t;
      return true;
}

• 队列的应用
  • 求解迷宫

       while (队不空循环)
       {
            出队方块e
	if (找到了出口,输出路径)
       }
        for (循环扫描每个方位)
        {
                switch(di)
	    {
	        四个方位的前进
	    }
	    if (死路)
	    {
              e.i=i1;  e.j=j1;
	      e.pre=qu->front;
	      enQueue(qu,e);	//(i1，j1)方块进队
	      mg[i1][j1]=-1;	//将其赋值-1
	    }
      }
          DestroyQueue(qu);		//销毁队列
          return false;

1.2 对栈和队列的认识和体会

• 先产生的数据后处理―栈（先进后出表）
• 先产生的数据先处理―队列（先进先出表）
• 顺序栈和队列，要考虑满和空的条件。不同的定义由不同的条件。
• 生活中不乏先来后到或特殊顺序的秩序流程，相关问题适合用栈或者队列加以解决。

2.PTA实验作业

2.1 jmu-ds-符号配对

2.1.1代码截图

2.1.2提交列表及说明

• Q1:
  • 出错在ElemType 定义为int型,而不是char型，导致出栈的是数字。

2.2 银行业务队列简单模拟

2.2.1代码截图

2.2.2提交列表及说明

• Q1:
  • A1：出错在哪一个队列是最后处理完的。判断标准应该是队列1的长度大于队列2的两倍，则队列1最后完成；反之，队列2最后完成。

3.阅读代码

3.1题目及解题代码

3.1.1该题的设计思路

• 首先，建立两个函数，分别用来判断是栈还是队列
  • 如果正着与反着相同，即为栈
  • 如果正着遍历相同，即为队列
• 其次，在主函数中，通过分支语句得到最终结果

3.1.2该题的伪代码

#include<cstdio>
#define maxn 1<<7
bool Stack(int* p, int* q, int n)//判断栈
{
    for (从头开始遍历p数组，从尾开始遍历q数组)
    {
        if (遍历对比，有一个不相同) return 0;
    }
    遍历完后return 1;
}
bool Queue(int* p, int* q, int n)//判断队列
{
    for (均从头遍历数组q,p)
    {
        if (遍历对比，有一个不相同) return 0;
    }
    遍历完后return 1;
}
int main()
{
    for (int N; scanf("%d", &N) == 1;)
    {
        while (N--)
        {
            定义长度n，两个数组p和q
            for (数据读入数组p)
            for (数据读入数组q)
            bool S = Stack(p, q, n), Q = Queue(p, q, n);//把判断是否是栈和队列的结果存入S和Q中
            if (S && !Q) printf("stack\n");
            else if (!S && Q) printf("queue\n");
            else if (S && Q) printf("both\n");
            else printf("neither\n");
        }
    }
    return 0;
}

3.1.3运行结果

3.1.4分析该题目解题的优势及难点

• 解题优势
  • 充分体现了分模块编程的优势。
  • 如果不分模块，将面临代码量大、代码重复等问题。
  • 函数分装恰到好处，四种情况封装两个函数，之后通过分支结构进行解决。而不是封装四个函数。
• 难点
  • 单单判断是否是栈或队列很容易
  • 难就难在，是栈非队，是队非栈，是栈且队，非栈非队等四种情况的判断上

3.2题目及解题代码

#include之algorithm

3.2.1该题的设计思路

• 按顺序建立队列，按优先级建立数组
• 如果对头的优先级和数组相同，且是所需要的任务，输出时间。

3.2.2该题的伪代码

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
struct point//定义结构体，存储序号，和优先级。
{
    int pla, num;//pla存序号，num存优先级
};
int cmp(int x, int y)//比较x,y。x>y时为真
{
    return x > y;
}
int main()
{
    定义测试次数T,队列长度n，所需的任务排序m，循环变量及标号i
    scanf("%d", &T);
    while (T--)
    {
        定义point结构体数组p
        定义int型数组a
        构建point队列Q
        读入队列长度n和所需任务的排序m
        for (i = 0; i < n; i++)
        {
            优先级存入数组a
            p[i].num = a[i], p[i].pla = i;
            Q.push(p[i]);//数组a的优先级存入对应的队列，并在把先后顺序存入队列
        }
        sort(a, a + n, cmp);//把数组a降序排列，即优先级从高到低排列
        int maxtop = 0;//当前数组a优先级最大的位置
        int num = 1;//时间
        while (1)
        {
            point x = Q.front();
            Q.pop();//队头出队给x
            if （队头的优先级是最高但不是所需的任务)
                优先级位置后推一位, 时间加一;
            else if (队头的优先级是最高且是所需任务)
                退出循环
            else//队头优先级不是最高
                之前出栈的队头入队
        }输出时间
    }
    return 0;
}

3.2.3运行结果

3.2.4解题优势及难点

• 优势
  • 用结构体来存储顺序及优先级，并构建出结构体的队列，很好的处理了数据如何存储的问题。
  • 通过降序的优先级数组和队头的优先级比较，完成题目的要求，十分巧妙。
• 难点
  • 该题目是实现功能的题目，也即不再是单纯的构建数据存储
  • 因此，如何构建出适当的数据结构是解决问题首先要考虑的
  • 其次，如何确定队头的优先级是否是最高的，是又一难点