一、判断题：

二、选择题：

三、编程题：

　　7-1 一元多项式求导：

输入样例：

  1. 3 4 -5 2 6 1 -2 0

输出样例：

  1. 12 3 -10 1 6 0

代码：

  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. int main()
  4. {
  5.     int a, b;
  6.     int s = 0;//用于计算系数和幂的乘积
  7.     cin>>a>>b;
  8.     if(b != 0)
  9.         cout<<(a*b)<<" "<<(b-1);//先计算一组，方便最后一组末尾的消除空格
  10.     else//特殊情况：即多项式为常数的情况
  11.     {
  12.         cout<<"0 0";
  13.         return 0;
  14.     }
  15.     while(scanf("%d %d", &a, &b) != EOF)//输入多组数据
  16.     {
  17.         if(b != 0)
  18.         {
  19.             s = a*b;
  20.             cout<<" "<<s<<" "<<(b-1);//进行求导计算
  21.         }
  22.     }
  23.     return 0;
  24. }

　　7-2 堆栈操作合法性：

输入样例：

  1. 4 10
  2. SSSXXSXXSX
  3. SSSXXSXXS
  4. SSSSSSSSSSXSSXXXXXXXXXXX
  5. SSSXXSXXX

输出样例：

  1. YES
  2. NO
  3. NO
  4. NO

代码：

  1. #include<stdio.h>
  2. #include<string.h>
  3. int main()
  4. {
  5.     char s[101];
  6.     int n, m;
  7.     scanf("%d%d", &n, &m);//读入数据
  8.     for(int i=0;i<n;i++)//
  9.     {
  10.         scanf("%s",s);
  11.         int len = strlen(s);//计算字符串长度
  12.         int flag1=0,flag2=1;
  13.         for(int j=0;j<len;j++)
  14.         {
  15.             if(s[j] == 'S')//统计入栈的次数
  16.                 flag1++;
  17.             else
  18.                 flag1--;
  19.             if(flag1<0||flag1>m)//若入栈次数小于零（出栈次数大宇入栈次数）或超出题目要球，均不符合
  20.             {
  21.                 printf("NO\n");
  22.                 flag2=0;
  23.                 break;
  24.             }
  25.         }
  26.         if(flag2==1)//符合题目要求同时输出字符串也符合要求
  27.         {
  28.             if(flag1==0)
  29.                 printf("YES\n");
  30.             else
  31.                 printf("NO\n");
  32.         }
  33.     }
  34. }

　　7-3 符号配对：

输入样例1：

  1. void test()
  2. {
  3.     int i, A[10];
  4.     for (i=0; i<10; i++) /*/
  5.         A[i] = i;
  6. }
  7. .

输出样例1：

  1. NO
  2. /*-?

输入样例2：

  1. void test()
  2. {
  3.     int i, A[10];
  4.     for (i=0; i<10; i++) /**/
  5.         A[i] = i;
  6. }]
  7. .

输出样例2：

  1. NO
  2. ?-]

输入样例3：

  1. void test()
  2. {
  3.     int i
  4.     double A[10];
  5.     for (i=0; i<10; i++) /**/
  6.         A[i] = 0.1*i;
  7. }
  8. .

输出样例3：

  1. YES

代码：

  1. #include <bits/stdc++.h>
  2. using namespace std;
  3. //#define OVERFLOW -2
  4. #define STACK_INIT_SIZE 100
  5. #define OK 1
  6. char temp;//创建全局变量，供函数内判断和主函数判断共同使用。
  7. typedef struct Stack//
  8. {
  9.     char *base;
  10.     char *top;
  11.     int stack_size;
  12. }Stack;
  13. void InitStack(Stack &s)//初始化
  14. {
  15.     s.base = (char*)malloc(STACK_INIT_SIZE*sizeof(char));
  16.     if(!s.base)
  17.         exit (OVERFLOW);
  18.     s.top = s.base;
  19.     s.stack_size = STACK_INIT_SIZE;
  20. }
  21. char GetTop(Stack S)//取栈顶
  22. {
  23.     if(S.base != S.top)
  24.         return *(S.top-1);
  25. }
  26. void Push(Stack &S, char e)//新元素入栈
  27. {
  28.     *S.top = e;
  29.     *S.top ++;
  30. }
  31. bool StackEmpty(Stack &S)//判断占空
  32. {
  33.     if(S.base == S.top)
  34.         return false;
  35.     return true;
  36. }
  37. bool Pop(Stack &S)//删除栈顶
  38. {
  39.     if(S.base == S.top)
  40.         return false;
  41.     S.top --;
  42.     return true;
  43. }
  44. bool StackCheck(Stack &S)//进行符号配对的判断
  45. {
  46.  
  47.     char test[101];
  48.     bool flag=true;
  49.     while(cin>>test)
  50.     {
  51.         if(test[0]=='.'&&test[1]=='\0')//如果一上来就符合结束规定，退出循环
  52.             break;
  53.         for(int i=0;test[i]!='\0';i++)//依次读入程序字符
  54.         {
  55.             if(test[i]=='/'&&test[i+1]=='*')//当读到这俩个符号时，进行入栈操作，i提前一位
  56.             {
  57.                 Push(S,test[i]),Push(S, test[i+1]);
  58.                 i++;
  59.             }
  60.             else if(test[i]=='(' || test[i]=='{' || test[i]=='[')//当读到括号的前半部分时，仍然入栈
  61.             {
  62.                 Push(S,test[i]);
  63.             }
  64.             else if(test[i]==']')
  65.             {
  66.                 if(StackEmpty(S)&&GetTop(S)=='[')//当读到】时，判断当前栈内是否有该括号的前半部分并且栈不空，若都成立， test[i]赋值给temp，退出循环
  67.                     Pop(S);
  68.                 else
  69.                 {
  70.                     flag=false;
  71.                     temp=test[i];
  72.                     break;
  73.                 }
  74.             }
  75.             else if(test[i]=='}')
  76.             {
  77.                 if(StackEmpty(S)&&GetTop(S)=='{')
  78.                     Pop(S);
  79.                 else
  80.                 {
  81.                     flag=false;
  82.                     temp=test[i];
  83.                     break;
  84.                 }
  85.             }
  86.             else if(test[i]==')')
  87.             {
  88.                 if(StackEmpty(S)&&GetTop(S)=='(')
  89.                     Pop(S);
  90.                 else
  91.                 {
  92.                     flag=false;
  93.                     temp=test[i];
  94.                     break;
  95.                 }
  96.             }
  97.             else if(test[i]=='*'&&test[i+1]=='/')
  98.             {
  99.                 if(StackEmpty(S)&&GetTop(S))
  100.                 {
  101.                     Pop(S);
  102.                     if(StackEmpty(S)&&GetTop(S)=='/')
  103.                     {
  104.                         Pop(S);
  105.                     }
  106.                     else
  107.                     {
  108.                         flag=false;
  109.                         temp=test[i];
  110.                         break;
  111.                     }
  112.                 }
  113.                 else
  114.                 {
  115.                     flag=false;
  116.                     temp=test[i];
  117.                     break;
  118.                 }
  119.             }
  120.         }
  121.     }
  122.     if(!StackEmpty(S)&&flag)
  123.         return true;
  124.     else
  125.         return false;
  126. }
  127. int main()
  128. {
  129.     Stack S;
  130.     InitStack(S);
  131.     if(!StackCheck(S))//根据题目要求，进行输出
  132.     {
  133.         printf("NO\n");
  134.         if(StackEmpty(S))
  135.         {
  136.             if(GetTop(S)=='(')
  137.                 printf("(-?\n");
  138.             if(GetTop(S)=='{')
  139.                 printf("{-?\n");
  140.             if(GetTop(S)=='[')
  141.                 printf("[-?\n");
  142.             if(GetTop(S)=='*')
  143.                 printf("/*-?\n");
  144.         }
  145.         else
  146.         {
  147.             if(temp==')')
  148.                 printf("?-)\n");
  149.             if(temp=='}')
  150.                 printf("?-}\n");
  151.             if(temp==']')
  152.                 printf("?-]\n");
  153.             if(temp=='*')
  154.                 printf("?-*/\n");
  155.         }
  156.     }
  157.     else
  158.         printf("YES\n");
  159. }

　　7-4 表达式转换：

输入样例：

  1. 2+3*(7-4)+8/4

输出样例：

  1. 2 3 7 4 - * + 8 4 / +

代码：

  1. //ceshi
  2. //2+3*(7-4)+8/4
  3. #include<stdio.h>
  4. #include<string.h>
  5. int Judge_Numeric(char c)//数字处理
  6. {
  7.     int flag = ((c>='0'&&c<='9'));
  8.     return flag;
  9. }
  10. int Judge_ZF(char c)
  11. {
  12.     int flag = (c=='+' ||c=='-');
  13.     return flag;
  14. }
  15. int Judge_CC(char c)
  16. {
  17.     int flag;
  18.     flag=(c=='*'||c=='/');
  19.     return flag;
  20. }
  21. int main()
  22. {
  23.     char a[31],b[31];
  24.     scanf("%s",a);
  25.     int flag1,flag2=0;
  26.     int j=0;
  27.     int len=strlen(a);
  28.     for(int i=0;i<len;i++)
  29.     {
  30.         flag1=1;
  31.         if(Judge_Numeric(a[i]))
  32.         {
  33.             if(flag2==0||(a[i-1]>='0'&&a[i-1]<='9')||a[i-1]=='.')
  34.                 printf("%c",a[i]);
  35.             else
  36.                 printf(" %c",a[i]);
  37.             flag2++;
  38.         }
  39.         if(a[i]=='.')
  40.         {
  41.             printf("%c",a[i]);
  42.         }
  43.         if(Judge_ZF(a[i]))
  44.         {
  45.             if(i==0)
  46.             {
  47.                 if(a[i]=='-')
  48.                     printf("%c",a[i]);
  49.                 flag1=0;
  50.             }
  51.             else
  52.             {
  53.                 if(a[i-1]=='-'||a[i-1]=='+'||a[i-1]=='*'||a[i-1]=='/'||a[i-1]=='(')
  54.                 {
  55.                     if(a[i]=='-')
  56.                     {
  57.                         printf(" %c",a[i]);
  58.                         flag2=0;
  59.                     }
  60.                     flag1=0;
  61.                 }
  62.             }
  63.             if(flag1==1)
  64.         {
  65.             if(j==0)
  66.             {
  67.                 b[j]=a[i];
  68.                 j++;
  69.             }
  70.             else if(b[j-1]=='+'||b[j-1]=='-'||b[j-1]=='(')
  71.                 {
  72.                     b[j]=a[i];
  73.                     j++;
  74.                 }
  75.             else if(b[j-1]=='*'||b[j-1]=='/')
  76.             {
  77.                 while(j>0)
  78.                 {
  79.                     if(b[j-1]=='(')
  80.                         break;
  81.                     printf(" %c",b[j-1]);
  82.                     j--;
  83.                 }
  84.                 b[j]=a[i];
  85.                 j++;
  86.             }
  87.         }
  88.         }
  89.         if(Judge_CC(a[i]))
  90.         {
  91.             if(j==0)
  92.             {
  93.                 b[j]=a[i];
  94.                 j++;
  95.             }
  96.             else if(b[j-1]||b[j-1]=='+'||b[j-1]=='-'||b[j-1]=='(')
  97.             {
  98.                 b[j]=a[i];
  99.                 j++;
  100.             }
  101.         }
  102.         if(a[i]==')')
  103.         {
  104.             while(j>0)
  105.             {
  106.                 if(b[j-1]=='(')
  107.                 {
  108.                     j--;
  109.                     break;
  110.                 }
  111.                 printf(" %c",b[j-1]);
  112.                 j--;
  113.             }
  114.         }
  115.          if(a[i]=='(')
  116.         {
  117.             b[j]=a[i];
  118.             j++;
  119.         }
  120.     }
  121.     while(j>0)
  122.     {
  123.         printf(" %c",b[j-1]);
  124.         j--;
  125.     }
  126. }

　　7-5 银行业务队列简单模拟：

输入样例：

  1. 8 2 1 3 9 4 11 13 15

输出样例：

  1. 1 3 2 9 11 4 13 15

代码：

  1. #include<stdio.h>
  2. int main()
  3. {
  4.     int a[1001];
  5.     int b[1001];//开辟两个数组，用于存放到两个窗口的人数；
  6.     int N;
  7.     int m = 0, n = 0;
  8.     int flag = 0;
  9.     scanf("%d",&N);
  10.     for(int i = 0; i < N; i++)
  11.     {
  12.         int temp;
  13.         scanf("%d",&temp);
  14.         if(temp % 2 == 0)
  15.         {
  16.             b[n] = temp;
  17.             n ++;
  18.         }
  19.         else
  20.         {
  21.             a[m] = temp;
  22.             m ++;
  23.         }
  24.     }
  25.     int m1 = 0, n1 = 0;
  26.     while(m1 < m || n1 < n)
  27.     {
  28.         if(m1 < m)
  29.         {
  30.             if(flag++)
  31.             {
  32.                 printf(" ");
  33.                 flag ++;
  34.             }
  35.             printf("%d", a[m1]);
  36.             m1 ++;
  37.  
  38.         }
  39.         if(m1 < m)
  40.         {
  41.             if(flag++)
  42.             {
  43.                 printf(" ");
  44.                 //flag ++;
  45.             }
  46.             printf("%d", a[m1]);
  47.             m1 ++;
  48.  
  49.         }
  50.         if(n1 < n)
  51.         {
  52.             if(flag++)
  53.             {
  54.                 printf(" ");
  55.                 //flag ++;
  56.             }
  57.             printf("%d", b[n1]);
  58.             n1 ++;
  59.         }
  60.     }
  61.     return 0;
  62. }

　　7-6 银行排队问题之单队列多窗口服务：

输入样例：

  1. 9
  2. 0 20
  3. 1 15
  4. 1 61
  5. 2 10
  6. 10 5
  7. 10 3
  8. 30 18
  9. 31 25
  10. 31 2
  11. 3

输出样例：

  1. 6.2 17 61
  2. 5 3 1

代码：

  1. #include<stdio.h>
  2. #include<string.h>
  3. typedef struct Q{
  4.     int arrive;//到达时间
  5.     int deal;//处理时间
  6. }Queue;
  7. Queue q[1010];
  8. int main()
  9. {
  10.     //Queue q[1002];
  11.     int head, tail;
  12.     int n;
  13.     int windows;
  14.     int k;
  15.     while(~scanf("%d", &n))
  16.     {
  17.         head = 0;
  18.         tail = 0;//定义头和尾，队列的
  19.         for(int i=0;i<n;i++)
  20.         {
  21.             scanf("%d%d", &q[tail].arrive, &q[tail].deal);//讲数据读入队列
  22.             if(q[tail].deal > 60)
  23.                 q[tail].deal = 60;
  24.             tail++;//最大处理时间默认为60
  25.         }
  26.         scanf("%d",&windows);//定义窗口数
  27.         int sum_wait_time=0;//总的等待时间
  28.         int wait_time=0;//最长等待时间
  29.         int wait=0;//个体等待时间
  30.         int finish_time[15]={0};//完成业务的人数
  31.         int windows_num[15]={0};//窗口人数
  32.         while(head < tail)
  33.         {
  34.             int flag=0;//做标记
  35.             int fastest=99999;//最快完成的时间
  36.             int index_fastest=0;//最快完成时间的下标
  37.             for(int j=0;j<windows;j++)//便利整个窗口
  38.             {
  39.                 if(finish_time[j]<q[head].arrive)//如果队列首位，到达时间比，完成时间大，就代表不需要等待
  40.                 {
  41.                     finish_time[j]=q[head].arrive+q[head].deal;//更新时间
  42.                     windows_num[j]++;//窗口人数加一
  43.                     flag=1;//标记，表示不需要等待
  44.                     head++;//剔除首位
  45.                     break;
  46.                 }
  47.                 if(fastest>finish_time[j])//如果需要等待，就记录各个窗口里最快完成的那个窗口的完成时间，和下标
  48.                 {
  49.                     fastest = finish_time[j];
  50.                     index_fastest=j;
  51.                 }
  52.             }
  53.             if(!flag)//需要等待
  54.             {
  55.                 wait=fastest-q[head].arrive;
  56.                 if(wait_time<wait)
  57.                 {
  58.                     wait_time = wait;
  59.                 }
  60.                 sum_wait_time+=wait;
  61.                 finish_time[index_fastest]=fastest+q[head].deal;
  62.                 windows_num[index_fastest]++;
  63.                 head++;
  64.             }
  65.         }
  66.         int zuihou=0;
  67.         for(k=0;k<windows;k++)
  68.         {
  69.             if(zuihou<finish_time[k])
  70.                 zuihou = finish_time[k];//求最大完成时间
  71.         }
  72.         printf("%.1lf %d %d\n",1.0*sum_wait_time/n,wait_time,zuihou);//输出，平均等待时间， 最长等待时间， 最后完成时间
  73.         for(int i=0;i<windows;i++)
  74.         {
  75.             printf("%d",windows_num[i]);//输出各个窗口的人数
  76.             if(i==windows-1)
  77.                 printf("\n");
  78.             else
  79.                 printf(" ");
  80.         }
  81.     }
  82.     return 0;
  83. }

　　7-7 列车调度：

输入样例：

  1. 9
  2. 8 4 2 5 3 9 1 6 7

输出样例：

  1. 4

代码：

  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. int arr[100001];//开辟数组并赋值
  4. int main()
  5. {
  6.     int n;
  7.     scanf("%d",&n);
  8.     //int arr[100001]={0};//开辟数组并赋值
  9.     int a;
  10.     int total=0;
  11.     for(int i=0;i<n;i++)
  12.     {
  13.         scanf("%d",&a);
  14.         if(total==0||arr[total-1]<a)//当前车辆比前面车辆大，开辟一条新路
  15.         {
  16.             arr[total++] = a;
  17.             //total ++;
  18.         }
  19.         else//当前车辆比前面车辆xiao，进一步判断跟前面的车还是跟其他比他大的车
  20.         {
  21.             int head=0, tail=total-1;
  22.             int mid;
  23.             while(head<tail)//二分查找，找大于该车的车号最小的车
  24.             {
  25.                 int mid=head+(tail-head)/2;
  26.                 if(arr[mid]==a)
  27.                     break;
  28.                 else if(arr[mid]>a)
  29.                     tail=mid-1;
  30.                 else
  31.                     head=mid+1;
  32.             }
  33.             arr[head] = a;
  34.         }
  35.     }
  36.     printf("%d",total);
  37.     return 0;
  38. }

SDUST数据结构 - chap3 栈和队列的更多相关文章

  1. 学习javascript数据结构(一)——栈和队列

    前言 只要你不计较得失,人生还有什么不能想法子克服的. 原文地址:学习javascript数据结构(一)--栈和队列 博主博客地址:Damonare的个人博客 几乎所有的编程语言都原生支持数组类型,因 ...

  2. python数据结构之栈与队列

    python数据结构之栈与队列 用list实现堆栈stack 堆栈:后进先出 如何进?用append 如何出?用pop() >>> >>> stack = [3, ...

  3. [ACM训练] 算法初级 之 数据结构 之 栈stack+队列queue (基础+进阶+POJ 1338+2442+1442)

    再次面对像栈和队列这样的相当基础的数据结构的学习,应该从多个方面,多维度去学习. 首先,这两个数据结构都是比较常用的,在标准库中都有对应的结构能够直接使用,所以第一个阶段应该是先学习直接来使用,下一个 ...

  4. python数据结构之栈、队列的实现

    这个在官网中list支持,有实现. 补充一下栈,队列的特性: 1.栈(stacks)是一种只能通过访问其一端来实现数据存储与检索的线性数据结构,具有后进先出(last in first out,LIF ...

  5. PHP数据结构：栈、队列、堆、固定数组

    数据结构:栈 队列: 堆: 固定尺寸的数组:

  6. 算法与数据结构(二) 栈与队列的线性和链式表示(Swift版)

    数据结构中的栈与队列还是经常使用的,栈与队列其实就是线性表的一种应用.因为线性队列分为顺序存储和链式存储,所以栈可以分为链栈和顺序栈,队列也可分为顺序队列和链队列.本篇博客其实就是<数据结构之线 ...

  7. 数据结构之栈和队列及其Java实现

    栈和队列是数据结构中非常常见和基础的线性表,在某些场合栈和队列使用很多,因此本篇主要介绍栈和队列,并用Java实现基本的栈和队列,同时用栈和队列相互实现. 栈:栈是一种基于“后进先出”策略的线性表.在 ...

  8. python——python数据结构之栈、队列的实现

    这个在官网中list支持,有实现. 补充一下栈,队列的特性: 1.栈(stacks)是一种只能通过访问其一端来实现数据存储与检索的线性数据结构,具有后进先出(last in first out,LIF ...

  9. JS数据结构的栈和队列操作

    数据结构:列表.栈.队列.链表.字典.散列.图和二叉查找树! 排序算法:冒牌.选择.插入.希尔.归并和快速! 查找算法:顺序查找和二分查找 在平时工作中,对数组的操作很是平常,它提供了很多方法使用,比 ...

随机推荐

  1. js下 Day13、面向对象

    一．对象 什么是对象: 一组无序的属性集合 创建对象两种方式: 对象字面量: var obj = {} 实例化: var obj = new Object() 对象取值: **[] ( ** 中括号) ...

  2. Java之String重点解析

    String s = new String("abc")这段代码创建了几个对象呢?s=="abc"这个判断的结果是什么?s.substring(0,2).int ...

  3. Ch2信息的表示和处理——caspp深入理解计算机系统

    目录 第2章 信息的表示和处理 2.1 信息存储 2.1.1 十六进制 一.表示法 二.加减 三.进制转换 2.1.2 字 2.1.3 数据大小 2.1.4 字节顺序与表示 一.字节的排列规则 二.打 ...

  4. 如何正确运用break、continue和return

    break.continue和return 一.break 作用:跳出(离break语句最近的)循环 栗子: for(int i = 1;i <= 100;i++){ System.out.pr ...

  5. 超简单的 Docker部署 SpringBoot项目 步骤

    很久之前就用过,一直没有好好写篇博客,今天就总结一下 创建一个 SpringBoot项目 创建一个SpringBoot项目并打成jar包,结构如图 编写 Dockerfile文件 FROM java: ...

  6. 物联网打工人必备：LiteOS Studio图形化调测能力

    摘要:本文会给大家介绍下LiteOS Studio的调测的几个知识点,包括: 调测配置,监视变量,反汇编代码同步展示,数值进制切换,跨平台编译调测,Qemu模拟器调测,多核调测,远程设备调测等. 掌握 ...

  7. 闲鱼上哪些商品抢手？Python 分析后告诉你

    1目 标 场 景 经常看到有朋友在闲鱼卖些小东西又或是自己擅长的一些技能,都能为他们带来不错的 睡后收入. 闲鱼上大量的商品,很难精准判断哪些受欢迎,哪些好卖:一个个录入数据去做数据分析,浪费时间的同 ...

  8. python简单的函数应用

    一个简单的函数应用,包括自定义函数,lambda函数,列表解析. 1 #!usr/bin/env python3 2 # -*- coding:utf-8 -*- 3 4 #开始定义函数 5 def ...

  9. HCIP --- BGP实验

    实验拓扑: 要求: R1.R2是EBGP关系,R2.R4是IBGP关系,R4.R5是EBGP邻居关系 R1与R5的环回可以通信 1.配置IP地址 2.BGP承载与IGP之上,所以给AS 2 启用IGP ...

  10. LINQ to Entities 不识别方法“System.String ToString(“yyyy-MM-dd”)”

    将Queryable转化为IEnumerable或者直接Tolist()