algo3-01~3-13.cpp 栈和队列主程序

1.  // algo3-9.cpp 用递归函数求解迷宫问题(求出所有解)
2.  #include"c1.h" // 根据《PASCAL程序设计》(郑启华编著)中的程序改编
3.  #include"func3-1.cpp" // 定义墙元素值为0，可通过路径为-1，通过路径为足迹
5.  void Try(PosType cur,int curstep)
6.  { // 由当前位置cur、当前步骤curstep试探下一点
7.    int i;
8.    PosType next; // 下一个位置
9.    PosType direc[4]={{0,1},{1,0},{0,-1},{-1,0}}; // {行增量,列增量},移动方向,依次为东南西北
10.    for(i=0;i<=3;i++) // 依次试探东南西北四个方向
11.    {
12.      next.x=cur.x+direc[i].x; // 根据移动方向，给下一位置赋值
13.      next.y=cur.y+direc[i].y;
14.      if(m[next.x][next.y]==-1) // 下一个位置是通路
15.      {
16.        m[next.x][next.y]=++curstep; // 将下一个位置设为足迹
17.        if(next.x!=end.x||next.y!=end.y) // 没到终点
18.          Try(next,curstep); // 由下一个位置继续试探(降阶递归调用，离终点更近)
19.        else // 到终点
20.        {
21.          Print(); // 输出结果(出口，不再递归调用)
22.          printf("/n");
23.        }
24.        m[next.x][next.y]=-1; // 恢复为通路，以便在另一个方向试探另一条路
25.        curstep--; // 足迹也减1
26.      }
27.    }
28.  }
30.  void main()
31.  {
32.    Init(-1); // 初始化迷宫，通道值为-1
33.    printf("此迷宫从入口到出口的路径如下:/n");
34.    m[begin.x][begin.y]=1; // 入口的足迹为1
35.    Try(begin,1); // 由第1步入口试探起
36.  }

 

1.  // algo3-1.cpp 调用算法3.1的程序
2.  #define N 8 // 定义待转换的进制N(2～9)
3.  typedef int SElemType; // 定义栈元素类型为整型
4.  #include"c1.h"
5.  #include"c3-1.h" // 采用顺序栈
6.  #include"bo3-1.cpp" // 利用顺序栈的基本操作
8.  void conversion() // 算法3.1
9.  { // 对于输入的任意一个非负10进制整数，打印输出与其等值的N进制数
10.    SqStack s;
11.    unsigned n; // 非负整数
12.    SElemType e;
13.    InitStack(s); // 初始化栈
14.    printf("将10进制整数n转换为%d进制数，请输入：n(>=0)=",N);
15.    scanf("%u",&n); // 输入非负十进制整数n
16.    while(n) // 当n不等于0
17.    {
18.      Push(s,n%N); // 入栈n除以N的余数(N进制的低位)
19.      n=n/N;
20.    }
21.    while(!StackEmpty(s)) // 当栈不空
22.    {
23.      Pop(s,e); // 弹出栈顶元素且赋值给e
24.      printf("%d",e); // 输出e
25.    }
26.    printf("/n");
27.  }
29.  void main()
30.  {
31.    conversion();
32.  }

 

1.  // algo3-2.cpp 改算法3.1，10进制→16进制
2.  typedef int SElemType; // 定义栈元素类型为整型
3.  #include"c1.h"
4.  #include"c3-1.h" // 采用顺序栈
5.  #include"bo3-1.cpp" // 利用顺序栈的基本操作
7.  void conversion()
8.  { // 对于输入的任意一个非负10进制整数，打印输出与其等值的16进制数
9.    SqStack s;
10.    unsigned n; // 非负整数
11.    SElemType e;
12.    InitStack(s); // 初始化栈
13.    printf("将10进制整数n转换为16进制数，请输入：n(>=0)=");
14.    scanf("%u",&n); // 输入非负十进制整数n
15.    while(n) // 当n不等于0
16.    {
17.      Push(s,n%16); // 入栈n除以16的余数(16进制的低位)
18.      n=n/16;
19.    }
20.    while(!StackEmpty(s)) // 当栈不空
21.    {
22.      Pop(s,e); // 弹出栈顶元素且赋值给e
23.      if(e<=9)
24.        printf("%d",e);
25.      else
26.        printf("%c",e+55); // 大于9的余数，输出相应的字符
27.    }
28.    printf("/n");
29.  }
31.  void main()
32.  {
33.    conversion();
34.  }

1.  // algo3-4.cpp 行编辑程序，实现算法3.2
2.  typedef char SElemType;
3.  #include"c1.h"
4.  #include"c3-1.h"
5.  #include"bo3-1.cpp"
6.  FILE *fp;
8.  void copy(SElemType c)
9.  { // 将字符c送至fp所指的文件中
10.    fputc(c,fp);
11.  }
13.  void LineEdit()
14.  { // 利用字符栈s，从终端接收一行并送至调用过程的数据区。算法3.2
15.    SqStack s;
16.    char ch;
17.    InitStack(s);
18.    printf("请输入一个文本文件,^Z结束输入:/n");
19.    ch=getchar();
20.    while(ch!=EOF)
21.    { // 当全文没结束(EOF为^Z键，全文结束符)
22.      while(ch!=EOF&&ch!='/n')
23.      { // 当全文没结束且没到行末(不是换行符)
24.        switch(ch)
25.        {
26.          case '#':if(!StackEmpty(s))
27.                     Pop(s,ch); // 仅当栈非空时退栈,c可由ch替代
28.                   break;
29.          case '@':ClearStack(s); // 重置s为空栈
30.                   break;
31.          default :Push(s,ch); // 其他字符进栈
32.        }
33.        ch=getchar(); // 从终端接收下一个字符
34.      }
35.      StackTraverse(s,copy); // 将从栈底到栈顶的栈内字符传送至文件
36.      fputc('/n',fp); // 向文件输入一个换行符
37.      ClearStack(s); // 重置s为空栈
38.      if(ch!=EOF)
39.        ch=getchar();
40.    }
41.    DestroyStack(s);
42.  }
44.  void main()
45.  {
46.    fp=fopen("ed.txt","w"); // 在当前目录下建立ed.txt文件，用于写数据，
47.    if(fp)                  // 如已有同名文件则先删除原文件
48.    {
49.      LineEdit();
50.      fclose(fp); // 关闭fp所指的文件
51.    }
52.    else
53.      printf("建立文件失败!/n");
54.  }

 

 

1.  // algo3-3.cpp 括号（()、[]和{}）匹配的检验
2.  typedef char SElemType;
3.  #include"c1.h"
4.  #include"c3-1.h"
5.  #include"bo3-1.cpp"
7.  void check()
8.  { // 对于输入的任意一个字符串，检验括号是否配对
9.    SqStack s;
10.    SElemType ch[80],*p,e;
11.    InitStack(s); // 初始化栈
12.    printf("请输入带括号（()、[]和{}）的表达式/n");
13.    gets(ch);
14.    p=ch; // p指向字符串的首字符
15.    while(*p) // 没到串尾
16.      switch(*p)
17.      {
18.        case '(':
19.        case '[':
20.        case '{':Push(s,*p++); // 左括号入栈，且p++
21.                 break;
22.        case ')':
23.        case ']':
24.        case '}':if(!StackEmpty(s)) // 栈不空
25.                 {
26.                   Pop(s,e); // 弹出栈顶元素
27.                   if(!(e=='('&&*p==')'||e=='['&&*p==']'||e=='{'&&*p=='}'))
28.                   { // 出现3种匹配情况之外的情况
29.                     printf("左右括号不配对/n");
30.                     exit(ERROR);
31.                   }
32.                 }
33.                 else // 栈空
34.                 {
35.                   printf("缺乏左括号/n");
36.                   exit(ERROR);
37.                 }
38.        default: p++; // 其它字符不处理，指针向后移
39.      }
40.    if(StackEmpty(s)) // 字符串结束时栈空
41.      printf("括号匹配/n");
42.    else
43.      printf("缺乏右括号/n");
44.  }
46.  void main()
47.  {
48.    check();
49.  }

1.  // algo3-5.cpp 利用栈求解迷宫问题(只输出一个解，算法3.3)
2.  #include"c1.h"
3.  #include"func3-1.cpp"
5.  int curstep=1; // 当前足迹，初值(在入口处)为1
6.  struct SElemType // 栈的元素类型
7.  {
8.    int ord; // 通道块在路径上的＂序号＂
9.    PosType seat; // 通道块在迷宫中的＂坐标位置＂
10.    int di; // 从此通道块走向下一通道块的＂方向＂(0～3表示东～北)
11.  };
13.  #include"c3-1.h" // 采用顺序栈存储结构
14.  #include"bo3-1.cpp" // 采用顺序栈的基本操作函数
16.  // 定义墙元素值为0，可通过路径为1，不能通过路径为-1，通过路径为足迹
17.  Status Pass(PosType b)
18.  { // 当迷宫m的b点的序号为1(可通过路径)，返回OK；否则，返回ERROR
19.    if(m[b.x][b.y]==1)
20.      return OK;
21.    else
22.      return ERROR;
23.  }
25.  void FootPrint(PosType a)
26.  { // 使迷宫m的a点的值变为足迹(curstep)
27.    m[a.x][a.y]=curstep;
28.  }
30.  void NextPos(PosType &c,int di)
31.  { // 根据当前位置及移动方向，求得下一位置
32.    PosType direc[4]={{0,1},{1,0},{0,-1},{-1,0}}; // {行增量,列增量},移动方向,依次为东南西北
33.    c.x+=direc[di].x;
34.    c.y+=direc[di].y;
35.  }
37.  void MarkPrint(PosType b)
38.  { // 使迷宫m的b点的序号变为-1(不能通过的路径)
39.    m[b.x][b.y]=-1;
40.  }
42.  Status MazePath(PosType start,PosType end) // 算法3.3
43.  { // 若迷宫m中存在从入口start到出口end的通道，则求得一条
44.    // 存放在栈中(从栈底到栈顶)，并返回TRUE；否则返回FALSE
45.    SqStack S; // 顺序栈
46.    PosType curpos; // 当前位置
47.    SElemType e; // 栈元素
48.    InitStack(S); // 初始化栈
49.    curpos=start; // 当前位置在入口
50.    do
51.    {
52.      if(Pass(curpos))
53.      { // 当前位置可以通过，即是未曾走到过的通道块
54.        FootPrint(curpos); // 留下足迹
55.        e.ord=curstep;
56.        e.seat=curpos;
57.        e.di=0;
58.        Push(S,e); // 入栈当前位置及状态
59.        curstep++; // 足迹加1
60.        if(curpos.x==end.x&&curpos.y==end.y) // 到达终点(出口)
61.          return TRUE;
62.        NextPos(curpos,e.di); // 由当前位置及移动方向，确定下一个当前位置
63.      }
64.      else
65.      { // 当前位置不能通过
66.        if(!StackEmpty(S)) // 栈不空
67.        {
68.          Pop(S,e); // 退栈到前一位置
69.          curstep--; // 足迹减1
70.          while(e.di==3&&!StackEmpty(S)) // 前一位置处于最后一个方向(北)
71.          {
72.            MarkPrint(e.seat); // 在前一位置留下不能通过的标记(-1)
73.            Pop(S,e); // 再退回一步
74.            curstep--; // 足迹再减1
75.          }
76.          if(e.di<3) // 没到最后一个方向(北)
77.          {
78.            e.di++; // 换下一个方向探索
79.            Push(S,e); // 入栈该位置的下一个方向
80.            curstep++; // 足迹加1
81.            curpos=e.seat; // 确定当前位置
82.            NextPos(curpos,e.di); // 确定下一个当前位置是该新方向上的相邻块
83.          }
84.        }
85.      }
86.    }while(!StackEmpty(S));
87.    return FALSE;
88.  }
90.  void main()
91.  {
92.    Init(1); // 初始化迷宫，通道值为1
93.    if(MazePath(begin,end)) // 有通路
94.    {
95.      printf("此迷宫从入口到出口的一条路径如下:/n");
96.      Print(); // 输出此通路
97.    }
98.    else
99.      printf("此迷宫没有从入口到出口的路径/n");
100.  }

 

1.  // algo3-6.cpp 表达式求值(输入的值在0～9之间，中间结果和输出的值在-128～127之间)，算法3.4
2.  typedef char SElemType; // 栈元素为字符型
3.  #include"c1.h"
4.  #include"c3-1.h"
5.  #include"bo3-1.cpp"
6.  #include"func3-2.cpp"
8.  SElemType EvaluateExpression() // 算法3.4，有改动
9.  { // 算术表达式求值的算符优先算法。设OPTR和OPND分别为运算符栈和运算数栈
10.    SqStack OPTR,OPND;
11.    SElemType a,b,c,x;
12.    InitStack(OPTR); // 初始化运算符栈OPTR和运算数栈OPND
13.    InitStack(OPND);
14.    Push(OPTR,'/n'); // 将换行符压入运算符栈OPTR的栈底(改)
15.    c=getchar(); // 由键盘读入1个字符到c
16.    GetTop(OPTR,x); // 将运算符栈OPTR的栈顶元素赋给x
17.    while(c!='/n'||x!='/n') // c和x不都是换行符
18.    {
19.      if(In(c)) // c是7种运算符之一
20.        switch(Precede(x,c)) // 判断x和c的优先权
21.        {
22.          case'<' :Push(OPTR,c); // 栈顶元素x的优先权低，入栈c
23.                   c=getchar();  // 由键盘读入下一个字符到c
24.                   break;
25.          case'=' :Pop(OPTR,x); // x='('且c=')'情况，弹出'('给x(后又扔掉)
26.                   c=getchar(); // 由键盘读入下一个字符到c(扔掉')')
27.                   break;
28.          case'>' :Pop(OPTR,x); // 栈顶元素x的优先权高，弹出运算符栈OPTR的栈顶元素给x(改)
29.                   Pop(OPND,b); // 依次弹出运算数栈OPND的栈顶元素给b，a
30.                   Pop(OPND,a);
31.                   Push(OPND,Operate(a,x,b)); // 做运算a x b，并将运算结果入运算数栈
32.        }
33.      else if(c>='0'&&c<='9') // c是操作数
34.      {
35.        Push(OPND,c-48); // 将该操作数的值(不是ASCII码)压入运算数栈OPND
36.        c=getchar(); // 由键盘读入下一个字符到c
37.      }
38.      else // c是非法字符
39.      {
40.        printf("出现非法字符/n");
41.        exit(ERROR);
42.      }
43.      GetTop(OPTR,x); // 将运算符栈OPTR的栈顶元素赋给x
44.    }
45.    Pop(OPND,x); // 弹出运算数栈OPND的栈顶元素(运算结果)给x(改此处)
46.    if(!StackEmpty(OPND)) // 运算数栈OPND不空(运算符栈OPTR仅剩'/n')
47.    {
48.      printf("表达式不正确/n");
49.      exit(ERROR);
50.    }
51.    return x;
52.  }
54.  void main()
55.  {
56.    printf("请输入算术表达式(输入的值要在0～9之间、中间运算值和输出结果在-128～127之间)/n");
57.    printf("%d/n",EvaluateExpression()); // 返回值(8位2进制，1个字节)按整型格式输出
58.  }

1.  // algo3-7.cpp 表达式求值(范围为int类型，输入负数要用(0-正数)表示)
2.  typedef int SElemType; // 栈元素类型为整型，改algo3-6.cpp
3.  #include"c1.h"
4.  #include"c3-1.h" // 顺序栈的存储结构
5.  #include"bo3-1.cpp" // 顺序栈的基本操作
6.  #include"func3-2.cpp"
8.  SElemType EvaluateExpression()
9.  { // 算术表达式求值的算符优先算法。设OPTR和OPND分别为运算符栈和运算数栈
10.    SqStack OPTR,OPND;
11.    SElemType a,b,d,x; // 改algo3-6.cpp
12.    char c; // 存放由键盘接收的字符，改algo3-6.cpp
13.    char z[11]; // 存放整数字符串，改algo3-6.cpp
14.    int i; // 改algo3-6.cpp
15.    InitStack(OPTR); // 初始化运算符栈OPTR和运算数栈OPND
16.    InitStack(OPND);
17.    Push(OPTR,'/n'); // 将换行符压入运算符栈OPTR的栈底(改)
18.    c=getchar(); // 由键盘读入1个字符到c
19.    GetTop(OPTR,x); // 将运算符栈OPTR的栈顶元素赋给x
20.    while(c!='/n'||x!='/n') // c和x不都是换行符
21.    {
22.      if(In(c)) // c是7种运算符之一
23.        switch(Precede(x,c)) // 判断x和c的优先权
24.        {
25.          case'<' :Push(OPTR,c); // 栈顶元素x的优先权低，入栈c
26.                   c=getchar();  // 由键盘读入下一个字符到c
27.                   break;
28.          case'=' :Pop(OPTR,x); // x='('且c=')'情况，弹出'('给x(后又扔掉)
29.                   c=getchar(); // 由键盘读入下一个字符到c(扔掉')')
30.                   break;
31.          case'>' :Pop(OPTR,x); // 栈顶元素x的优先权高，弹出运算符栈OPTR的栈顶元素给x(改)
32.                   Pop(OPND,b); // 依次弹出运算数栈OPND的栈顶元素给b，a
33.                   Pop(OPND,a);
34.                   Push(OPND,Operate(a,x,b)); // 做运算a x b，并将运算结果入运算数栈
35.        }
36.      else if(c>='0'&&c<='9') // c是操作数，此语句改algo3-6.cpp
37.      {
38.        i=0;
39.        while(c>='0'&&c<='9') // 是连续数字
40.        {
41.          z[i++]=c;
42.          c=getchar();
43.        }
44.        z[i]=0; // 字符串结束符
45.        d=atoi(z); // 将z中保存的数值型字符串转为整型存于d
46.        Push(OPND,d); // 将d压入运算数栈OPND
47.      }
48.      else // c是非法字符，以下同algo3-6.cpp
49.      {
50.        printf("出现非法字符/n");
51.        exit(ERROR);
52.      }
53.      GetTop(OPTR,x); // 将运算符栈OPTR的栈顶元素赋给x
54.    }
55.    Pop(OPND,x); // 弹出运算数栈OPND的栈顶元素(运算结果)给x(改此处)
56.    if(!StackEmpty(OPND)) // 运算数栈OPND不空(运算符栈OPTR仅剩'/n')
57.    {
58.      printf("表达式不正确/n");
59.      exit(ERROR);
60.    }
61.    return x;
62.  }
64.  void main()
65.  {
66.    printf("请输入算术表达式,负数要用(0-正数)表示/n");
67.    printf("%d/n",EvaluateExpression());
68.  }

1.  // algo3-8.cpp 用递归调用求Ackerman(m,n)的值
2.  #include<stdio.h>
3.  int ack(int m,int n)
4.  {
5.    int z;
6.    if(m==0)
7.      z=n+1; // 出口
8.    else if(n==0)
9.      z=ack(m-1,1); // 对形参m降阶
10.    else
11.      z=ack(m-1,ack(m,n-1)); // 对形参m、n降阶
12.    return z;
13.  }
15.  void main()
16.  {
17.    int m,n;
18.    printf("Please input m,n:");
19.    scanf("%d,%d",&m,&n);
20.    printf("Ack(%d,%d)=%d/n",m,n,ack(m,n));
21.  }

1.  // algo3-10.cpp Hanoi塔问题，调用算法3.5的程序
2.  #include<stdio.h>
4.  int c=0; // 全局变量，搬动次数
6.  void move(char x,int n,char z)
7.  { // 第n个圆盘从塔座x搬到塔座z
8.    printf("第%i步: 将%i号盘从%c移到%c/n",++c,n,x,z);
9.  }
11.  void hanoi(int n,char x,char y,char z) // 算法3.5
12.  { // 将塔座x上按直径由小到大且自上而下编号为1至n的n个圆盘
13.    // 按规则搬到塔座z上。y可用作辅助塔座
14.    if(n==1) // (出口)
15.      move(x,1,z); // 将编号为1的圆盘从x移到z
16.    else
17.    {
18.      hanoi(n-1,x,z,y); // 将x上编号为1至n-1的圆盘移到y，z作辅助塔(降阶递归调用)
19.      move(x,n,z); // 将编号为n的圆盘从x移到z
20.      hanoi(n-1,y,x,z); // 将y上编号为1至n-1的圆盘移到z，x作辅助塔(降阶递归调用)
21.    }
22.  }
24.  void main()
25.  {
26.    int n;
27.    printf("3个塔座为a、b、c，圆盘最初在a座，借助b座移到c座。请输入圆盘数：");
28.    scanf("%d",&n);
29.    hanoi(n,'a','b','c');
30.  }

 

 

1. 1.  // algo3-12.cpp 银行业务模拟。实现算法3.6、3.7的程序
   2.  #define Qu 4 // 客户队列数
   3.  #define Khjg 5 // 两相邻到达的客户的时间间隔最大值
   4.  #define Blsj 30 // 每个客户办理业务的时间最大值
   5.  #include"func3-3.cpp" // 包含algo3-12.cpp和algo3-13.cpp共同用到的函数和变量等
   7.  LinkQueue q[Qu]; // Qu个客户队列
   8.  QElemType customer; // 客户记录，临时变量
   9.  //FILE *fq; // 文件型指针，用于指向a.txt文件
   11.  void OpenForDay()
   12.  { // 初始化事件链表ev且插入第1个到达事件，初始化Qu个队列
   13.    int i;
   14.    InitList(ev); // 初始化事件链表ev为空
   15.    en.OccurTime=0; // 设定第1位客户到达时间为0(银行一开门，就有客户来)
   16.  //fprintf(fq,"首位客户到达时刻=%3d,",en.OccurTime);
   17.    en.NType=Qu; // 到达
   18.    OrderInsert(ev,en,cmp); // 将第1个到达事件en有序插入事件表ev中，在bo2-6.cpp中
   19.    for(i=0;i<Qu;++i) // 初始化Qu个队列
   20.      InitQueue(q[i]);
   21.  }
   23.  int Minimum(LinkQueue Q[])
   24.  { // 返回最短队列的序号，若有并列值，返回队列序号最小的
   25.    int l[Qu];
   26.    int i,k=0;
   27.    for(i=0;i<Qu;i++)
   28.      l[i]=QueueLength(Q[i]);
   29.    for(i=1;i<Qu;i++)
   30.      if(l[i]<l[0])
   31.      {
   32.        l[0]=l[i];
   33.        k=i;
   34.      }
   35.    return k;
   36.  }
   38.  void CustomerArrived()
   39.  { // 处理客户到达事件en(en.NType=Qu)
   40.    QElemType f;
   41.    int durtime,intertime,i;
   42.    ++CustomerNum; // 客户数加1
   43.    Random(durtime,intertime); // 生成当前客户办理业务的时间和下一个客户到达的时间间隔2个随机数
   44.    et.OccurTime=en.OccurTime+intertime; // 下一客户et到达时刻=当前客户en的到达时间+时间间隔
   45.    et.NType=Qu; // 下一客户到达事件
   46.    i=Minimum(q); // 求长度最短队列的序号，等长为最小的序号(到达事件将入该队)
   47.  //if(CustomerNum<=20) // 输出前20个客户到达信息到文件a.txt中
   48.  //  fprintf(fq,"办理业务的时间=%2d,所排队列=%d/n下一客户到达时刻=%3d,",durtime,i,et.OccurTime);
   49.    if(et.OccurTime<CloseTime) // 下一客户到达时银行尚未关门
   50.      OrderInsert(ev,et,cmp); // 按升序将下一客户到达事件et插入事件表ev中，在bo2-6.cpp中
   51.    f.ArrivalTime=en.OccurTime; // 将当前客户到达事件en赋给队列元素f
   52.    f.Duration=durtime;
   53.    EnQueue(q[i],f); // 将f入队到第i队列(i=0～Qu-1)
   54.    if(QueueLength(q[i])==1) // 该元素为队头元素
   55.    {
   56.      et.OccurTime=en.OccurTime+durtime; // 设定一个离开事件et
   57.      et.NType=i;
   58.      OrderInsert(ev,et,cmp); // 将此离开事件et按升序插入事件表ev中
   59.    }
   60.  }
   62.  void CustomerDeparture()
   63.  { // 处理客户离开事件en(en.NType<Qu)
   64.    int i;
   65.    i=en.NType; // 确定离开事件en发生的队列序号i
   66.    DeQueue(q[i],customer); // 删除第i队列的排头客户
   67.    TotalTime+=en.OccurTime-customer.ArrivalTime; // 客户逗留时间=离开事件en的发生时刻-该客户的到达时间
   68.    if(!QueueEmpty(q[i]))
   69.    { // 删除第i队列的排头客户后，第i队列仍不空
   70.      GetHead(q[i],customer); // 将第i队列新的排头客户赋给customer
   71.      et.OccurTime=en.OccurTime+customer.Duration; // 设定离开事件et,新排头的离开时间=原排头的离开时间+新排头办理业务的时间
   72.      et.NType=i; // 第i个队列的离开事件
   73.      OrderInsert(ev,et,cmp); // 将此离开事件et按升序插入事件表ev中
   74.    }
   75.  }
   77.  void main()
   78.  {
   79.  //fq=fopen("a.txt","w"); // 打开a.txt文件，用于写入客户到达信息
   80.  //fp=fopen("b.txt","w"); // 打开b.txt文件，用于写入有序事件表的历史记录
   81.    printf("请输入银行营业时间长度(单位:分): ");
   82.    scanf("%d",&CloseTime);
   83.  //srand(time(0)); // 设置随机数种子，以使每次运行程序产生的随机数不同(time(0)是长整型数，与调用时间有关)
   84.    Bank_Simulation();
   85.  //fclose(fq); // 关闭a.txt
   86.  //fclose(fp); // 关闭b.txt
   87.  }
    // algo3-11.cpp 利用非循环顺序队列采用广度搜索法求解迷宫问题(一条路径)
2.  #include"c1.h"
3.  #include"func3-1.cpp"
4.  #define D 8 // 移动方向数，只能取4和8。(8个，可斜行；4个，只可直走)
6.  typedef struct // 定义队列元素和栈元素为同类型的结构体
7.  {
8.    PosType seat; // 当前点的行值，列值
9.    int pre; // 前一点在队列中的序号
10.  }QElemType,SElemType; // 栈元素和队列元素
11.  #include"c3-1.h" // 栈的存储结构
12.  #include"bo3-1.cpp" // 栈的基本操作
13.  #include"c3-4.h" // 队列的存储结构
14.  #include"bo3-4.cpp" // 非循环顺序队列的基本操作(1)
15.  #include"bo3-9.cpp" // 非循环顺序队列的基本操作(2)
17.  struct // 移动数组，移动方向由正东起顺时针转
18.  {
19.    int x,y;
20.  }move[D]={
21.  #if D==8
22.        {0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1}};
23.  #endif
24.  #if D==4
25.        {0,1},{1,0},{0,-1},{-1,0}};
26.  #endif
28.  void Path()
29.  { // 广度搜索法求一条迷宫路径
30.    SqQueue2 q; // 采用非循环顺序队列
31.    QElemType qf,qt; // 当前点和下一点
32.    SqStack s; // 采用顺序栈
33.    int i,flag=1; // 当找到出口，flag=0
34.    qf.seat.x=begin.x; // 将入口作为当前点
35.    qf.seat.y=begin.y;
36.    qf.pre=-1; // 设入口(第一点)的上一点的序号=-1
37.    m[qf.seat.x][qf.seat.y]=-1; // 初始点设为-1(标记已访问过)
38.    InitQueue(q);
39.    EnQueue(q,qf); // 起点入队
40.    while(!QueueEmpty(q)&&flag)
41.    { // 队列中还有没被广度搜索过的点且还没找到出口
42.      DeQueue(q,qf); // 出队qf为当前点
43.      for(i=0;i<D;i++) // 向各个方向尝试
44.      {
45.        qt.seat.x=qf.seat.x+move[i].x; // 下一点的坐标
46.        qt.seat.y=qf.seat.y+move[i].y;
47.        if(m[qt.seat.x][qt.seat.y]==1)
48.        { // 此点是通道且不曾被访问过
49.          m[qt.seat.x][qt.seat.y]=-1; // 标记已访问过
50.          qt.pre=q.front-1; // qt的前一点处于队列中现队头减1的位置(没删除)
51.          EnQueue(q,qt); // 入队qt
52.          if(qt.seat.x==end.x&&qt.seat.y==end.y) // 到达终点
53.          {
54.            flag=0;
55.            break;
56.          }
57.        }
58.      }
59.    }
60.    if(flag) // 搜索完整个队列还没到达终点
61.      printf("没有路径可到达终点！/n");
62.    else // 到达终点
63.    {
64.      InitStack(s); // 初始化s栈
65.      i=q.rear-1; // i为待入栈元素在队列中的位置
66.      while(i>=0) // 没到入口
67.      {
68.        Push(s,q.base[i]); // 将队列中的路径入栈(栈底为出口，栈顶为入口)
69.        i=q.base[i].pre; // i为前一元素在队列中的位置
70.      }
71.      i=0; // i为走出迷宫的足迹
72.      while(!StackEmpty(s))
73.      {
74.        Pop(s,qf); // 依照由入口到出口的顺序弹出路径
75.        i++;
76.        m[qf.seat.x][qf.seat.y]=i; // 标记路径为足迹(标记前的值为-1)
77.      }
78.      printf("走出迷宫的一个方案：/n");
79.      Print(); // 输出m数组
80.    }
81.  }
83.  void main()
84.  {
85.    Init(1); // 初始化迷宫，通道值为1
86.    Path(); // 求一条迷宫路径
87.  }

1.  // algo3-13.cpp 使用排队机的银行业务模拟
2.  #define Qu 4 // 窗口数
3.  #define Khjg 5 // 两相邻到达的客户的时间间隔最大值
4.  #define Blsj 30 // 每个客户办理业务的时间最大值
5.  #include"func3-3.cpp" // 包含algo3-12.cpp和algo3-13.cpp共同用到的函数和变量等
7.  LinkQueue q; // 排队机队列q
8.  QElemType customer[Qu]; // Qu个客户队列元素, 存放正在窗口办理业务的客户的信息
9.  //FILE *fq; // 文件型指针，用于指向c.txt文件
10.  //int j=0; // 计数器，产生c.txt文件用到
11.  Boolean chk[Qu]; // 窗口状态，1为闲，0为忙
13.  void OpenForDay()
14.  { // 初始化事件链表ev且插入第1个到达事件，初始化排队机q，初始化Qu个窗口为1(空闲)
15.    int i;
16.    InitList(ev); // 初始化事件链表ev为空
17.    en.OccurTime=0; // 设定第1位客户到达时间为0(银行一开门，就有客户来)
18.    en.NType=Qu; // 到达
19.    OrderInsert(ev,en,cmp); // 将第1个到达事件en有序插入事件表ev中，在bo2-6.cpp中
20.    InitQueue(q); // 初始化排队机队列q
21.    for(i=0;i<Qu;i++)
22.      chk[i]=1; // 初始化Qu个窗口为1(空闲)
23.  }
25.  int ChuangKou()
26.  { // 返回空闲窗口的序号(0～Qu-1)，若有多个窗口空闲，返回序号最小的。若无空闲窗口，返回Qu
27.    int i;
28.    for(i=0;i<Qu;i++)
29.      if(chk[i])
30.        return i;
31.    return i;
32.  }
34.  void CustomerArrived()
35.  { // 处理客户到达事件en(en.NType=Qu)，与algo3-12.cpp不同
36.    QElemType f;
37.    int durtime,intertime,i;
38.    ++CustomerNum; // 客户数加1
39.    Random(durtime,intertime); // 生成当前客户办理业务的时间和下一个客户到达的时间间隔2个随机数
40.    et.OccurTime=en.OccurTime+intertime; // 下一客户et到达时刻=当前客户en的到达时间+时间间隔
41.    et.NType=Qu; // 下一客户到达事件
42.    if(et.OccurTime<CloseTime) // 下一客户到达时银行尚未关门
43.      OrderInsert(ev,et,cmp); // 按升序将下一客户到达事件et插入事件表ev中，在bo2-6.cpp中
44.    f.ArrivalTime=en.OccurTime; // 将当前客户到达事件en赋给队列元素f
45.    f.Duration=durtime;
46.    EnQueue(q,f); // 将当前客户f入队到排队机
47.    i=ChuangKou(); // 求空闲窗口的序号
48.    if(i<Qu) // 有空闲窗口
49.    {
50.      DeQueue(q,customer[i]); // 删去排队机的排头客户(也就是刚入队的f由排队机到i号窗口)
51.  //  if(j++<20) // 输出前20个客户到达信息及处理业务窗口信息到文件c.txt中
52.  //    fprintf(fq,"客户到达时刻=%3d,办理业务的时间=%2d,所在窗口=%d/n",customer[i].ArrivalTime,customer[i].Duration,i);
53.      et.OccurTime=en.OccurTime+customer[i].Duration; // 设定一个i号窗口的离开事件et
54.      et.NType=i; // 第i号窗口的离开事件
55.      OrderInsert(ev,et,cmp); // 将此离开事件et按升序插入事件表ev中
56.      chk[i]=0; // i号窗口状态变忙
57.    }
58.  }
60.  void CustomerDeparture()
61.  { // 处理客户离开事件en(en.NType<Qu)，与algo3-12.cpp不同
62.    int i;
63.    i=en.NType; // 确定离开事件en发生的窗口序号i
64.    chk[i]=1; // i号窗口状态变闲
65.    TotalTime+=en.OccurTime-customer[i].ArrivalTime; // 客户逗留时间=离开事件en的发生时刻-该客户的到达时间
66.    if(!QueueEmpty(q))
67.    { // 第i窗口的客户离开后，排队机仍不空
68.      DeQueue(q,customer[i]); // 删去排队机的排头客户并将其赋给customer[i](排队机的排头客户去i窗口办理业务)
69.  //  if(j++<20) // 输出前20个客户到达信息及处理业务窗口信息到文件c.txt中
70.  //    fprintf(fq,"客户到达时刻=%3d,办理业务的时间=%2d,所在窗口=%d/n",customer[i].ArrivalTime,customer[i].Duration,i);
71.      chk[i]=0; // i号窗口状态变忙
72.      et.OccurTime=en.OccurTime+customer[i].Duration; // 设定customer[i]的离开事件et,客户的离开时间=原客户的离开时间+当前客户办理业务的时间
73.      et.NType=i; // 第i号窗口的离开事件
74.      OrderInsert(ev,et,cmp); // 将此离开事件et按升序插入事件表ev中
75.    }
76.  }
78.  void main()
79.  {
80.  //fq=fopen("c.txt","w"); // 打开c.txt文件，用于写入客户到达信息
81.  //fp=fopen("d.txt","w"); // 打开d.txt文件，用于写入有序事件表的历史记录
82.    printf("请输入银行营业时间长度(单位:分): ");
83.    scanf("%d",&CloseTime);
84.  //srand(time(0)); // 设置随机数种子,以使每次运行程序产生的随机数不同(time(0)是长整型数,与调用时间有关)
85.    Bank_Simulation();
86.  //fclose(fq); // 关闭c.txt
87.  //fclose(fp); // 关闭d.txt
88.  }