第一篇：数据结构课程设计报告(HuffMan编码器)
《数据结构》课程设计报告
题目：HuffMan编码器
数据结构设计报告
计科0403
041106308
雷娜
目 录
一．问题描述
二．基本要求(需求分析)
三．•概要设计(设计思想、实现方法、模块设计)
四．•详细设计(数据结构设计、算法设计、算法分析)
五．测试数据及测试结果
六．课程设计小结(心得体会、存在问题、改进措施)
一． 问题描述
利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。
第 1 页
数据结构设计报告
计科0403
041106308
雷娜
但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。试为这样的信息收发站写一个哈夫曼码的编/译码系统。二． 基本要求(需求分析)
一个完整的系统应具有以下功能：
（1）I：初始化（Initialization）。从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件hfmTree中。
（2）E：编码（Encoding）。利用已建好的哈夫曼树（如不在内存，则从文件hfmTree中读入），对文件ToBeTran中的正文进行编码，然后将结果存入文件CodeFile中。
（3）D：译码（Decoding）。利用已建好的哈夫曼树将文件CodeFile中的代码进行译码，结果存入文件TextFile中。
（4）P：印代码文件（Print）。将文件CodeFile以紧凑格式显示在终端上，每行50个代码。同时将此字符形式的编码文件写入文件CodePrin中。
（5）T：印哈夫曼树（Tree printing）。将已在内存中的哈夫曼树以直观的方式（树或凹入表形式）显示在终端上，同时将此字符形式的哈夫曼树写入文件TreePrint中。[测试数据] 用下表给出的字符集和频度的实际统计数据建立哈夫曼树，并实现以下报文的编码和译码：“THIS PROGRAM IS MY FAVORITE”。
字符 空格 A
B
C
D
E
F
G
H
I
J
K
L
M 频度 186
13 22 32 103 21 15 47 57 1
20 字符 N
O
P
Q
R
S
T
U
V
W
X
Y
Z 频度 57
15 1
51 80 23 8 1 1[实现提示]
（1）编码结果以文本方式存储在文件CodeFile中。
（2）用户界面可以设计为“菜单”方式：显示上述功能符号，再加上“Q”，表示退出运行Quit。请用户键入一个选择功能符。此功能执行完毕后再显示此菜单，直至某次用户选择了“Q”为止。
（3）在程序的一次执行过程中，第一次执行I，D或C命令之后，哈夫曼树已经在内存了，不必再读入。每次执行中不一定执行I命令，因为文件hfmTree可能早已建好。
三． 概要设计(设计思想、实现方法、模块设计)哈夫曼编码是一种效率比较高的变长无失真信源编码方法，它的平均码长
第 2 页
数据结构设计报告
计科0403
041106308
雷娜
最短，因此是最佳编码。我采用二进制哈夫曼编码。
1． 设计思想
a、原理：构造一个码树。
b、编码步骤：
(1)将信源符号按概率从大到小的顺序排列，为方便起见，令p(x1)≥p(x2)≥„≥p(xn)。
(2)对概率最小的两个信源符号求其概率之和，同时给两个符号分别赋予码元“0 ”和“1”。将“概率之和”当作一个新符号的概率，与剩下符号的概率一起，形成一个缩减信源，结果得到一个只包含（n－1）个信源符号的新信源，称为信源的第一次缩减信源,用S1表示。
(3)将缩减信源S1的符号仍按概率从大到小的顺序排列，重复步骤2，得到只含（n－2）个符号的缩减信源S2。
(4)重复上述步骤，直至缩减信源只剩下两个符号为止，此时所剩两个符号的概率之和必为1。
(5)按上述步骤实际上构造了一个码树，从树根到端点经过的树枝即为码字。
2． 实现方法
第一，哈夫曼编码实际上构造了一个码树，码树从最上层的端点开始构造，直到树根束，最后得到一个横放的码树，因此，编出的码是即时码。
第二，哈夫曼编码采用概率匹配方法来决定各码字的码长，概率大的符号对应于短码，概率小的符号对应于长码，从而使平均码长最小。
第三，每次对概率最小的两个符号求概率之和形成缩减信源时，就构造出两个树枝，由于给两个树枝赋码元时是任意的，因此编出的码字并不惟一。
3． 模块设计
第 3 页
数据结构设计报告
计科0403
041106308
雷娜
1．进入的操作界面：
（图一）
2．输入字符串，及编码结果
（图二）
3．统计不同字符数及带权路径长度
（图三）
4．各字符编码明细
第 4 页
数据结构设计报告
计科0403
041106308
雷娜
（图四）
四．详细设计(数据结构设计、算法设计、算法分析)
（一）数据结构设计
1)结点类型：
//huffcode.cpp
typedef struct HaffmanTreeNode {
char ch, code[15];
int weight;
int parent, lchild, rchild;} HTNode, *HaTree;
typedef struct { HTNode arr[MAX_NODE];
int total;} HTree;
2)基本操作：
第 5 页
数据结构设计报告
计科0403
041106308
雷娜
int statistic_char(char *text, HTree *t);int create_htree(HTree *t);void coding(HTree *t, int head_i, char *code);void print_htree_ldr(HTree *t, int head_i, int deep, int* path);void code_string(char *text, HTree *t,char *codes);
（二）算法设计
在哈夫曼编码过程中，对缩减信源符号按概率由大到小的顺序重新排列时，应使合并后的新符号尽可能排在靠前的位置，这样可使合并后的新符号重复编码次数减少，使短码得到充分利用。
（三）算法分析
(1)有效的信源编码可取得较好的冗余压缩效果。(2)有效的信源编码可使输出码元概率均匀化。
4． 测试数据及测试结果
1．输入简短英文字符串：
（图五）
2．输入数字英文混合串：
第 6 页
数据结构设计报告
计科0403
041106308
雷娜
（图六）
3．混合串：
（图七）
4．输入复杂无规则长串：
（图八）
第 7 页
数据结构设计报告
计科0403
041106308
雷娜
六．课程设计小结(心得体会、存在问题、改进措施)
本次程序设计使我不仅深化理解了教学内容，进一步提高灵活运用数据结构、算法和程序设计技术的能力，而且在总体分析、总体结构设计、算法设计、程序设计、上机操作及程序调试等基本技能方面受到了综合训练。
本次实验我选择Huffman编译码器的课题。帮助我深入研究树的各种存储结构的特性及其应用。由于课程设计着眼于原理与应用的结合，使我学会把书本上和课堂上学到的知识用于解决实际问题，从而培养了一部分计算机软件工作所需要的动手能力。
我通过对Huffman编译码原理的学习，再通过分析、设计、编码、调试等各环节，实现了Huffman编译码器的数据实现和界面实现。在Huffman编译码器数据结构的算法设计中我同时用到了多种技术和方法，如算法设计的构思方法，算法的编码，递归技术，与二叉树和树相关的技术等。从而帮助我深入学习研究了树的各种存储结构的特性及其应用。
为了实现界面友好的要求，我决定采用MFC的界面操作，所以必须以C++为基本语言，但是由于学习数据结构课程是基于PASCAL，实验数据结构部分设计遇到一些语法冲突。但是通过课程实践学习，我又开始熟悉C++的编程环境，从而实现了在不同语言上数据结构思想的统一。
此次课程设计并没有划定具体题目，包括算法需求都由我们度量，思路开阔。我始终和同学探讨并独立研究新的功能的实现。通过尝试来学习，通过实践去理解。
当然，通过多天来的上机实践，我获取了一些心得：
一．充分准备。由于课题宽泛，很多同学去网上下了界面优良的源程序。相对而言在DOS下编程的我开始时很焦急，不知如何实现界面友好。准备充分是很重要的，为了实现MFC，我重新学习了C++语言。
二．冷静，耐心投入。集中精力地编程，不被外界影响，使自己的思路始终连贯不被打断。对待每一个错误，都要仔细分析，太过焦急，不仅不能及时的改正错误，还对后面的编程造成影响。
三．要有一种坚持不懈的毅力，不管自己的程序多么复杂，多么冗长，要坚持不懈的去完成。冷静思考。
四．要对自己有信心，出错是必然的。“屡战屡败，屡败屡战”，不怕受挫的心理承受能力和从零开始的决心是走向成功的必要条件。
五．学会与别人学习讨论，但不依赖别人，可以通过借鉴思路从而创新，但决不照搬别人的东西。
第 8 页
数据结构设计报告
计科0403
041106308
雷娜
通过查找资料，我发现我们做Huffman编码和解码时，一般都要在内存通过指针生成Huffman树，这是一个比较费时间、费空间的过程。实际上，真正的Huffman编码程序经常使用其他更快的数据结构来完成树的生成，如散列等。所以我的课题有待继续学习研究。
•用户手册/使用说明
（图九）
1．在此处输入要编码的字符串，点击进行编码。
2．再次输入时再点击可成功使用，不会受之前结果影响。
•附录(源程序清单)//huffcode.cpp //C编写的源代码，原来含有writef()以及printf(),但由于最终用MFC界面实现，故删去，只作为一 //些功能子函数被MFC的对话框类调用。//另外，对于类型申明等已包含于头文件。#include “stdafx.h” #include “huffcode.h”
/*
统计字符出现的频率
*/ int statistic_char(char *text, HTree *t){
int i, j;
int text_len = strlen(text);
t->total = 0;
for(i=0;i for(j=0;j if(t->arr[j].ch == text[i]) { 第 9 页 数据结构设计报告 计科0403 041106308 雷娜 t->arr[j].weight ++; break; } if(j==t->total){ t->arr[t->total].ch = text[i]; t->arr[t->total].weight = 1; t->total ++; } } return t->total;} int create_htree(HTree *t){ int i; int total_node = t->total * 2-1;int min1, min2;/* 权最小的两个结点 */ int min1_i, min2_i;/* 权最小结点对应的编号 */ int leaves = t->total; for(i=0;i t->arr[i].parent =-1; t->arr[i].rchild =-1; t->arr[i].lchild =-1; } while(t->total < total_node){ min1 = min2 = MAX_WEIGHT; for(i=0;i 对每一个结点 */ if(t->arr[i].parent ==-1 /* 结点没有被合并 */ && t->arr[i].weight < min2){ /* 结点的权比最小权小 */ if(t->arr[i].weight < min1){ /* 如果它比最小的结点还小 */ min2_i = min1_i;min2 = min1; min1_i = i; min1 = t->arr[i].weight; } else { min2_i = i; min2 = t->arr[i].weight; } } } t->arr[t->total].weight = min1 + min2; t->arr[t->total].parent =-1; t->arr[min1_i].parent = t->total; t->arr[min2_i].parent = t->total; t->arr[t->total].ch = ' '; 第10 页 数据结构设计报告 计科0403 041106308 雷娜 t->total ++; } return 0;} /* 对哈夫曼树进行编码 */ void coding(HTree *t, int head_i, char *code){ if(head_i ==-1)return; if(t->arr[head_i].lchild ==-1 && t->arr[head_i].rchild ==-1){ strcpy(t->arr[head_i].code, code);/ } else { int len = strlen(code); strcat(code, “0”); coding(t, t->arr[head_i].lchild, code); code[len] = '1'; coding(t, t->arr[head_i].rchild, code); code[len] = ' '; } } /* 对字符进行编码 */ void code_string(char *text, HTree *t,char *codes){ int i, j, text_len = strlen(text); int n = 0; for(i=0;i char ch = text[i]; for(j=0;j strcat(codes, t->arr[j].code); break; } } } // DlgString.cpp //作为执行文件，通过MFC的可视化界面实现HuffMan编译码器 #include “stdafx.h” #include “iostream.h” #include “string.h” #include “math.h” #include “HUFFMANTREE.h” #include “DlgString.h” #include “huffcode.h” #ifdef _DEBUG 第11 页 数据结构设计报告 计科0403 041106308 雷娜 #define new DEBUG_NEW #undef THIS_FILE static char THIS_FILE[] = __FILE__;#endif CDlgString::CDlgString(CWnd* pParent /*=NULL*/): CDialog(CDlgString::IDD, pParent){ //{{AFX_DATA_INIT(CDlgString)m_inStr = _T(“");m_outstr = _T(”“);m_wpl = _T(”“);m_number = _T(”“);//}}AFX_DATA_INIT } void CDlgString::DoDataExchange(CDataExchange* pDX){ CDialog::DoDataExchange(pDX);//{{AFX_DATA_MAP(CDlgString)DDX_Control(pDX, IDC_LIST1, m_chars);DDX_Text(pDX, IDC_EDIT_STR, m_inStr);DDX_Text(pDX, IDC_STATIC_OUT, m_outstr);DDX_Text(pDX, IDC_STATIC_WPL, m_wpl);DDX_Text(pDX, IDC_STATIC_NUM, m_number);//}}AFX_DATA_MAP } BEGIN_MESSAGE_MAP(CDlgString, CDialog)//{{AFX_MSG_MAP(CDlgString)ON_NOTIFY(NM_CLICK, IDC_LIST1, OnClickList1)//}}AFX_MSG_MAP END_MESSAGE_MAP() // CDlgString message handlers void CDlgString::OnOK(){ UpdateData(true);// TODO: Add extra validation here m_chars.DeleteAllItems();CBrush brush(RGB(225,30,100)); CClientDC dc(this); dc.FillRect(CRect(630,10,1050,280),&brush);// 清屏 int i,ci,n,nn,wpl,len; 第12 页 数据结构设计报告 计科0403 041106308 雷娜 int x,y,h; HTree t; m_outstr= _T(”“); int path[16]={0}; char code[128] = ”“; char codes[128] = ”“; CString str; char text[128]; strcpy(text,m_inStr); n=statistic_char(text, &t);//n用于存储叶子个数 h=(int)(log(n)/log(2)+1); create_htree(&t);//建树 coding(&t, t.total-1, code);//编码 UpdateData(TRUE); wpl=0; for(ci=1;ci<=n;ci++){ CClientDC *pdc = new CClientDC(this); CPen pen;pen.CreatePen(PS_SOLID,1,RGB(225,250,250));CPen *oldpen =(CPen *)pdc->SelectObject(&pen);//建笔 x=800;y=20;// 原始坐标设定 pdc->MoveTo(x,y);//每次路径都从同一源点开始 str.Format(_T(”%c“),t.arr[ci-1].ch);/*对n个叶子的明细输入列表*/ nn=m_chars.InsertItem(m_chars.GetItemCount(),str); str.Format(_T(”%s“),t.arr[ci-1].code);m_chars.SetItemText(nn,1,str); str.Format(_T(”%d“),t.arr[ci-1].weight);m_chars.SetItemText(nn,2,str); len=strlen(t.arr[ci-1].code);str.Format(_T(”%d“),len);m_chars.SetItemText(nn,3,str); 第13 页 数据结构设计报告 计科0403 041106308 雷娜 wpl+=t.arr[ci-1].weight*len; for(i=0;i { y=y+50; if(t.arr[ci-1].code[i]=='0') //向左 { x=x-8*(h-i+1); pdc->LineTo(x,y); pdc->MoveTo(x,y); if(i==len-1){ str.Format(_T(”%c“),t.arr[ci-1].ch); pdc->TextOut(x,y+10,str);} } else if(t.arr[ci-1].code[i]=='1') { //向右 x=x+8*(h-i+1); pdc->LineTo(x,y); pdc->MoveTo(x,y); if(i==len-1){ str.Format(_T(”%c“),t.arr[ci-1].ch); pdc->TextOut(x,y+10,str);} } } } str.Format(_T(”%d“),wpl); m_wpl=str; //在对话框上显示最短带权路径 str.Format(_T(”%d“),n); m_number=str; //在对话框上显示不同的编码字符总数 UpdateData(false); code_string(text, &t,codes); str.Format(_T(”%s“),codes); m_outstr=str; //在对话框上输出对应于输入字符串的编码结果 UpdateData(false); } void CDlgString::OnClickList1(NMHDR* pNMHDR, LRESULT* pResult){ // TODO: Add your control notification handler code here *pResult = 0;} 第14 页 数据结构设计报告 计科0403 041106308 雷娜 BOOL CDlgString::OnInitDialog()//列表初始化 { CDialog::OnInitDialog(); m_font.CreateFont(17,0,0,0,FW_BLACK, 0,0,0，DEFAULT_CHARSET, OUT_CHARACTER_PRECIS, CLIP_CHARACTER_PRECIS，DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, ”Courier New“); m_chars.SetFont(&m_font); m_chars.SetExtendedStyle(LVS_EX_FULLROWSELECT |LVS_EX_GRIDLINES); m_chars.SetBkColor(RGB(100,000,100));m_chars.SetTextColor(RGB(255,255,255));m_chars.SetTextBkColor(RGB(150,010,200));m_chars.InsertColumn(0, ”字符“, LVCFMT_CENTER, 50);m_chars.InsertColumn(1, ”编码“, LVCFMT_CENTER, 100);m_chars.InsertColumn(2, ”频度(权)“, LVCFMT_LEFT, 95); m_chars.InsertColumn(3, ”路径长度", LVCFMT_LEFT, 95); return TRUE;// return TRUE unless you set the focus to a control // EXCEPTION: OCX Property Pages should return FALSE } 第15 页 哈夫曼编码与解码 一、设计思想 在设计本程序时，主要用到的算法有如下三个： 一、创建哈夫曼树算法； 二、求哈夫曼编码算法； 三、求哈夫曼解码算法。 创建哈夫曼树算法如下： 1)存储结构：构造由信息元素与对应的权值组成的信息元素结构体来存储已给定的字母与其权重信息；构造由信息元素、权值、当前结点的父结点、左结点、右结点组成的哈夫曼树结点结构体来存储树结点的信息，还会很方便地帮助创建哈夫曼树；构造由信息元素与对应的哈夫曼编码结构体来存储哈夫曼编码信息；方便进行对数据的编码。2)结构体数组处理：哈夫曼树没有度为 1 的结点，若一个哈夫曼树由 n 个叶子结点，则该哈夫曼树共有2n-1个结点。应用以上的原理，根据用户输入的信息元素的个数n开辟大小为2n-1的哈夫曼树数组来满足创建哈夫曼树的需要，并对此数组进行初始化，叶子结点的信息元素与权值即给定的的信息元素与权值；非叶子结点的信息元素与权值设置为空值；所有哈夫曼树结点的父结点、左结点、右结点设置为 0。 3)选择权值最小与次小：在进行比较的过程中循环取出权值进行比较，设置两个s1，s2分别记录本次循环最小与次小的权值，进行下一次的比较选择。返回权值最小与次小的哈夫曼树结点信息。 4)生成小树：应用3)中想法，在用户输入的信息元素中选择权值中最小与次小的元素分别赋值给右叶子结点与左叶子结点，并把这两个权值之和赋值给这两个结点的父结点，记录父结点位置。 5)生成哈夫曼树：再应用3)4)把这些小树的父结点的权值进行比较选择，选择权值比较大的设置为新的右结点的权值，权值比较小的设置为左结点，把这两个权值的和赋值给新的父结点；以此重复进行，最终生成哈夫曼树。 求哈夫曼编码算法如下 1)采用无栈非递归遍历哈夫曼树：每次站在根结点遍历哈夫曼树，直至到达某一个叶子结点为止，并临时用一个数组记录遍历过程中每个结点的状态。编码完成后再复制给哈夫曼编码结构体中的编码数组。 2)遍历与编码：在逻辑上，遍历时向左子时，编码为0，向右子为1，将每次的结点状态记录连接即哈夫曼编码；站在根结点上，若到左子上记录此时的结点状态为0，并把指针指向左子，进行下一次的遍历，若到右结点上记录此时的结点状态1，并把指针指向右子，进行下一次的判断遍历；重复进行，到达某一个叶子结点为止，完毕后，将每次 哈夫曼编码与解码 下面是哈夫曼编码过程的大致过程（如图2）： 图2 为huffman树的各节点进行编码 下面是对指定文件内信息编码的大致过程（如图3）： 图3 信息的编码 哈夫曼编码与解码 { int j,k;/*找出第一个单节点树*/ for(k=1;k<=i;k++) { if(ht[k].parent!=0) { } continue; s1=k; break; } /*找出其中权重最小的树*/ for(j=1;j<=i;j++) { if(ht[j].parent!=0) { } { } continue; if(ht[j].weight s1=j; } /*找出第二个单节点树*/ for(k=1;k<=i;k++) { if(ht[k].parent!=0||k==s1){ } continue; s2=k; break; } /*找出其中权重次小的树*/ for(j=1;j<=i;j++) { if(ht[j].parent!=0) { } { continue; if(ht[j].weight s2=j; 哈夫曼编码与解码 cd[--Istart]='0'; } { } else/*右1*/ cd[--Istart]='1'; hc[i]=(char *)malloc((n-Istart)*sizeof(char)); strcpy(hc[i], &cd[Istart]);/*将临时储存的code拷贝至hc中*/ } } free(cd);/*释放cd*/ } void main(){ char text[300];/*声明储存源码或Huffman码的临时数组*/ int i,j,count,choice;/*储存字母数组*/ /*储存字母对应权重的数组*/ char zi[26]={'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'}; int w[26]={64,13,22,32,103,21,15,47,57,1,5,32,20,57,63,15,1,48,51,80,23,8,18,1,16,1}; huffmantree ht; huffmancode hc; HuffmanTree(ht,w,zi,26);/*生成huffman树*/ huffmancoding(ht,hc,26);/*根据huffman树生成huffman码*/ FILE *fp; printf(“[1]Encoding...n”);printf(“[2]Decoding...n”);scanf(“%d”,&choice);if(choice==1)/*1为编码*/ { char file[20];printf(“Please choice the file:”);/*输入需要编码的文件名*/ scanf(“%s”,file);printf(“******************从%s文件读取字符串******************n”,file);if((fp=fopen(file,“r”))==NULL){ } fgets(text,300,fp);/*从文件中读取字符串*/ fclose(fp);printf(“Source code is:”);/*输出读取的字符串*/ puts(text);printf(“cannot open this filen”); printf(“Please choice function:”);/*选择编码还是译码*/ 哈夫曼编码与解码 } } } printf(“n”);} /*显示由部分电码译码得到的字符，并准备对后面的电码进行译码*/ printf(“%c”,ht[count].letter);count=51; 四、运行结果 下图是对SourceCode.txt文件信息进行编码，所得到的效果图（如图5所示）： 图5 对SourceCode.txt文件进行编码 下图是对CodeFile.txt文件中Huffman码进行译码，所得到的效果图（如图6所示）： 图6 对CodeFile.txt文件中Huffman码进行译码 数据结构课程设计 散列表的应用:插队买票 专业 计算机科学与技术（网络技术） 金玲 计算机131 1310704114 张静林 2015年1月23日 学生姓名 班学级 号 指导教师 完成日期 目录概述……………………………………………………………………………………1 1.1 课程设计目的……………………………………………………………………….1 1.2 课程设计内容……………………………………………………………………….1 2 系统需求分析……………………………………………………………………….1 2.1 主体功能…………………………………………………………………………....2 3系统概要设计…………………………………………………………………………2 3.1 系统流程图………………………………………………………………………….2 4 系统详细设计…………………………………………………………………………3 5 测试……………………………………………………………………………………5 5.1 测试方案…………………………………………………………………………….5 5.2 测试结果…………………………………………………………………………….5 6 小结……………………………………………………………………………………5 参考文献…………………………………………………………………………………5 附录………………………………………………………………………………………7 附录1 源程序清单……………………………………………………………………...7 概述 1.1 课程设计目的 数据结构课程设计是为数据结构课程独立开设的实践性教学环节。数据结构课程设计对于巩固数据结构知识，加强学生的实际动手能力和提高学生综合素质是十分必要的。课程设计的目的： 1．要求学生达到熟练掌握C语言的基本知识和技能。 2．了解并掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力。3．提高程序设计和调试能力。学生通过上机实习，验证自己设计的算法的正确性。学会有效利用基本调试方法，迅速找出程序代码中的错误并且修改。 4．培养算法分析能力。分析所设计算法的时间复杂度和空间复杂度，进一步提高程序设计水平。 5．初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能。 1.2课程设计内容 本课程设计的任务是写一个程序模拟这种情况。每个队伍都允许插队。如果你在排队，有一个以上的朋友要求插队，则你可以安排他们的次序。每次一个人入队，并且如果这个入队的人发现队伍中有自己的朋友，则可以插入到这个朋友的后面；当队伍中的朋友不止一个的时候，这个人会排在最后一个朋友的后面；如果队伍中没有朋友，则他只能够排在这个队伍的最后面。每一个入队的人都先进行上述的判断。当队伍前面的人买到车票之后，依次出队。系统需求分析 2.1 主体功能 程序从“input.txt”文件读入测试用例，一个文件可包含多个测试用例。每个用例的第一行是朋友组的数目n（1<=n<=1000)。对于一个朋友组以朋友的数目j（1<=j<=1000）开始，由朋友的个数以及他们的名字组成，一个空格后接该组朋友的名字，以空格分开，并且每个人的名字都不同。每个名字不超过四个字母，由{A，B，...，Z，a，b，...，z}组成。一个朋友组最多有1000个人，每个人只属于一个朋友组。n=0时，测试数据结束。 下面是一些具体命令：.ENQUEUE——X入队;.DEQUEUE——排队头的人买票，离开队伍，即出队；.STOP——一个测试用例结束。 测试结果输出到“output.txt”文件中。每个测试用例第一行输出“Scenario#k”，k是测试用例的序号（从1开始）。对每一个出队命令，输出刚买票离开队伍的人名。两个测试试用例 之间隔一空行，最后一个用例结束不输出空行。系统概要设计 3.1 系统流程图 系统详细设计 本题目主要解决两个问题：一是怎么存放和查找大量数据（主要是姓名）；二是怎么操作“ENQUEUE”和“DEQUEUE”命令。 用散列表来存放和查找数据。由于最多有1000个朋友组，每组最多有1000人，使用平方探测法解决冲突，则表的大小是2*（1000*1000），所以选择TableSize=2000003（2000003是大于2000000的最小素数）。同一个组内的都是朋友，所以每个人除了记录他的名字name，还要记录他属于哪个组group，另外用info来表示该单元是否被占用，数据结构如图4.1所示。散列函数是根据Honer法则计算一个以64为阶的多项式，如图4.2所示。冲突解决方法采用平方探测法，如图4.3所示。 #define TabSize 2000003 typedef struct hashtab *PtrToHash;struct hashtab /*散列表数据结构*/ { char name[5]; /*名字*/ int group; /*属于哪个朋友组*/ char info; /*标志位，该单元是否被占用*/ };图4.1数据结构：散列表 Int Hash(char *key,int TableSize){ Int HashVal=0; While(key!=NULL) HashVal=(HashVal<<6)+*key; Return HashVal%TableSize;} 图4.2散列函数 Long int Find(PtrToHash hash,char *c){ key=c; CurrentPos=Hash(key,TableSize); CollisionNum=0; While((单元被占用)and(单元内的名字与查找的名字不同)) { CurrentPos+=2*(++CollisionNum)-1; If(CurrentPos>=TabSize) CurrentPos=TabSize; } Return CurrentPos;} 图4.3用平方探测法解决冲突 第二个问题是关于怎么操作“ENQUEUE”和“DEQUEUE”命令。这可以用队列来模拟。由于有插队现象的存在，不能单纯的用一个数组来表示队列，因为这样的话，插入一个朋友，则他后面的人都要往后移一个单位，删除一个人，则他后面的人都要前移一个，会降低效率。所以，采用一个Index标记来表示当前元素的后继元素，最后一个单元的后继元素是第0个，形成环，数据结构如图4.4所示。不用链表是因为链表存放指针也需要空间，并且链表插入、删除的效率没有数组高。 typedef struct Que *PtrToQue;struct Que /*队列数据结构*/ { long int HashVal; /*散列值*/ long int Index; /*在中的队列序号*/ };图4.4数据结构：队列 输入ENQUEUE命令，如果队伍里有朋友，则排在朋友后面；如果没有朋友，则排在队尾。入队时，用一个数组记录每个朋友组的最后一位，以便下一个朋友到来时排到他后面，这个数组被称为“插队数组”。 输入DEQUEUE命令，则根据“先进先出”，按照各个元素和它后继元素的先后顺序，每次删除队列重的第一个。程序结构如图4.5所示。 While(读测试文件){ if(输入”ENQUEUE”) { 读入名字； 插入散列表； 插入队列； } else if(输入”DEQUEUE”) { 删除队列第一个名字； 将该名字输出到文件； } else stop;} 图4.5入队、出队操作 测试 5.1 测试方案 按输入要求输入正常测试数据，测试程序是否能正确解决问题，得到正确答案。应注意边界测试。例如，将n，j分别取为1的用例和n为1000的用例。n，j比较大时需写程序生成测试用例。 不按输入要求输入数据，测试程序能否对输入内容进行数据合法性检测并进行相应的异常处理。例如，将n或j取为小于1或大于1000的数，名字超过4个字母等情况下的测试用例。5.2 测试结果 小结 在前面的学习过程中我们学到了很多知识而这次课程设计又是对我们所学的 一次总结，刚开始，可以说是没有头绪，于是就去图书馆找资料，找到了一些关于程序方面的，可这远远不够，这只是小小的开始。我们必须掌握很多已学的知识才能很好的完成本次的课程设计。在这次课程设计中，总的感觉是我遇到了很多困难这主要是由于我编写代码的经验不足，有时虽然是一个很小的问题但解决起来却花费了我不少的时间，值得欣慰的是，当自己苦思冥想或者和其它同学一起探讨把问题解决的时候我还是觉得获益非浅，这就是在摸索中寻求到的知识。在设计时也免不了存在着些不足，所以在今后的学习中我会努力取得更大的进步。虽然对着电脑做程序，有些累，可当看到劳动成果时，却有另一番滋味。 参考文献 [1]范策，周世平，胡晓琨.《算法与数据结构（C语言版）》[M].北京：机械工业出版社，2004 [2]严蔚敏.《数据结构（C语言版）》.北京：清华大学出版社，2004 [3]许卓群，杨冬青，唐世渭，张铭.《数据结构与算法》.北京：高等教育出版社，2004 [4]徐孝凯.《数据结构实用教程（第二版）》.北京：清华大学出版社，2006 附录 附录1 源程序清单 #include /*散列表大小TabSize 是大于表最大空间的素数*/ #define Max 1000001 /*队列空间最大值*/ struct hashtab;typedef struct hashtab *PtrToHash;struct hashtab /*散列表数据结构*/ { char name[5]; /*名字*/ int group; /*属于哪个朋友组*/ char info; /*标志位，该单元是否被占用*/ };struct Que;typedef struct Que *PtrToQue;struct Que /*队列数据结构*/ { long int HashVal; /*散列值*/ long int Index; /*在中的队列序号*/ }; int hashedx=0; /*标记元素是否已经在散列表里*/ long int Find(PtrToHash hash,char *c)/*查找在散列表中的位置*/ { char *key;long int CurrentPos,CollisionNum; key=c;for(CurrentPos=0;*key;++key) /*散列函数，计算散列值*/ CurrentPos=(CurrentPos<<6)+*key;CurrentPos%=TabSize; /*散列值*/ CollisionNum=0;/*如果当前单元被占用：单元内的元素与当前操作的名字不同，使用平方探测法解决冲突；与当前操作的名字相同，则直接返回在散列中的位置*/ while((hash[CurrentPos].info)&&(strcmp(hash[CurrentPos].name,c))) { /*平方探测法*/ CurrentPos+=2*(++CollisionNum)-1; if(CurrentPos>=TabSize) CurrentPos-=TabSize;} if((hash[CurrentPos].info)&&(strcmp(hash[CurrentPos].name,c)==0)) /*元素已经在散列表里*/ hashedx=1;else /*元素不在散列表里*/ hashedx=0;return CurrentPos;/*返回在散列表中的位置*/ } int main(){ long int Find(PtrToHash hash,char *c); /*查找在散列表中的位置*/ PtrToHash hash; /*散列表*/ PtrToQue queue; /*队列*/ int *grouppos; /*记录每个朋友组的最后一位，即插队数组*/ int n; /*测试用例数目*/ int num; /*当前测试用例序号*/ long int i,ii,j,key,temp;long int head,last; /*队列的头和尾*/ char c[8],tempc[8]; /*名字*/ FILE *fpin,*fpout; /*输入、输出文件指针*/ if(!(fpin=fopen(“input.txt”,“r”))) /*打开测试文件*/ { printf(“fopen error!”); /*文件打开错误*/ return-1;} if(!(fpout=fopen(“output.txt”,“w”))) /*打开输出文件*/ { printf(“fopen error!”); return-1;} hash=(PtrToHash)malloc(sizeof(struct hashtab)*TabSize);/*为散列表申请空间*/ queue=(PtrToQue)malloc(sizeof(struct Que)*Max);/*为队列申请空间*/ grouppos=(int *)malloc(sizeof(int)*1000);/*申请空间记录每个朋友组的最后一位*/ for(i=0,j=1;i queue[i].Index=j;queue[i-1].Index=0;/*最后一个单元的后继单元是第0个，形成环*/ num=0;for(fscanf(fpin,“%d”,&n);n;fscanf(fpin,“%d”,&n))/*输入当前测试用例的朋友组数*/ { if(n<1||n>1000) /*处理异常输入n*/ { fprintf(fpout,“n is out of rangen”); return-1; } num++; if(num!=1) /*两个测试用例间输入一空行*/ fprintf(fpout,“n”); for(i=0;i hash[i++].info=0; /*初始化散列表，标记位置0*/ for(i=0;i /*对每一组朋友*/ { fscanf(fpin,“%d”,&j); /*当前组里的人数*/ if(j<1||j>1000) /*处理异常输入j*/ { fprintf(fpout,“j is out of rangen”); return-1; } for(;j;--j) { fscanf(fpin,“%s”,c); /*输入名字*/ for(ii=0;ii tempc[ii]=' '; strcpy(tempc,c); ii=0; while(tempc[ii]!=' ') /* 是否由四个以内字母组成*/ { if(tempc[ii]<'A'||('Z' { fprintf(fpout,“Group %d: Nonstandard namen ”,i); return-1; } ii++; } key=Find(hash,c); /*找到在散列表中的位置*/ if(hashedx==1)/*重名*/ { fprintf(fpout,“repeated name %sn”,c); return-1; } strcpy(hash[key].name,c);/*插入散列表*/ hash[key].info=1; /*标记置1，该单元被占用*/ hash[key].group=i; /*记录他属于哪个组*/ } } for(i=0;i<1000;) grouppos[i++]=0;/*初始化插队数组*/ head=0; /*初始化队列头、尾标记*/ last=0;fprintf(fpout,“Scenario #%dn”,num);/*输出当前用例序号到文件*/ for(fscanf(fpin,“%s”,c);;fscanf(fpin,“%s”,c))/*输入命令*/ { if(*c=='E') /*入队命令*/ { fscanf(fpin,“%s”,c); /*输入名字*/ key=Find(hash,c); /*查找在散列表中的位置*/ if(hashedx==0)/*散列表里没这个人*/ { fprintf(fpout,“no %sn”,c); return-1;} temp=queue[0].Index; /*队列第0个位置记录队尾的后继单元*/ queue[0].Index=queue[temp].Index; /*在队列中申请一个新单元，队尾标记后移一个位置 */ queue[temp].HashVal=key;/*入队*/ if(!head)/*如果是队列里的第一个元素 */ last=head=temp;/*队头、队尾标记指向第一个元素*/ if(!grouppos[hash[key].group])/*如果队列里没朋友*/ { queue[temp].Index=0;/*队尾指向对头，形成环*/ queue[last].Index=temp;/*前一次队尾的后继元素是当前元素*/ last=temp; /*队尾标记指向当前元素*/ grouppos[hash[key].group]=temp;/*插队数组记录该朋友组里已入队的最后一位*/ } else/*如果队列中已经有他的朋友*/ { queue[temp].Index=queue[grouppos[hash[key].group]].Index; /*插队到朋友的后面*/ queue[grouppos[hash[key].group]].Index=temp; /*插队到朋友后面一位的前面*/ grouppos[hash[key].group]=temp; /*替换插队数组里该组的元素为当前元素*/ if(hash[queue[last].HashVal].group==hash[key].group) /*如果当前元素和前一元素是朋友，队尾标志指向当前元素*/ last=temp; } } else if(*c=='D')/*出队命令*/ { if(last==0) /*不能对空队列执行出队命令*/ { fprintf(fpout,“Empty queue!nCan't execute DEQUEUE!n”); return-1; } fprintf(fpout,“%sn”,hash[queue[head].HashVal].name); /*输出队头元素到文件*/ temp=head; head=queue[temp].Index; /*队列第一位出队，队头标记后移一位*/ queue[temp].Index=queue[0].Index; /*队列第0个元素后移一位*/ queue[0].Index=temp; /*释放空间*/ if(grouppos[hash[queue[temp].HashVal].group]==temp) /*当前删除的元素是该朋友组在队列里的最后一位*/ grouppos[hash[queue[temp].HashVal].group]=0; if(last==temp) /*出队后，队列为空*/ last=0; } else /*输入 “STOP”*/ break; /*测试结束*/ } } fprintf(fpout,“b”);fclose(fpin);fclose(fpout);return 1;} 正文要求：对每一个题目，正文必须包括以下几个方面 知识点回顾： 实验要求： 实验过程：包括设计思路，算法描述，程序清单，调试等等； 实验小结： 注意：（1）正文中字体用小四号宋体，行间距1.25倍行距； （2）页码居中； （3）A4纸双面打印，在纸的左侧装订。 （4）上交的课程设计报告控制在10页以内。 齐鲁工业大学 理学院 信计11-1 郑桥 一、提示：对于单窗口的服务系统知识点回顾如下： 1、什么是负指数分布？ 又称指数分布。泊松事件流的等待时间（相继两次出现之间的间隔）服从指数分布。用于描述非老化性元件的寿命（元件不老化，仅由于突然故障而毁坏）。常假定排队系统中服务器的服务时间和Petri网中变迁的实施速率符合指数分布。 2、用C语言如何产生随机序列？ double rd_MN1(double m,double n){ double r;if(m>n){r=n;n=m;m=r;};r =((double)rand()/((double)(RAND_MAX)+(double)(1)));r = m+ r*(n-m);return r;} 3、用C语言如何产生负指数分布的时间序列？ double expntl(double x){ double z;do { z =((double)rand()/ RAND_MAX);} while((z == 0)||(z == 1));return(-x * log(z));//z相当于1-x,而x相当于1/lamda。} 其中的x相当于1/λ 4、排队论简单叙述； 排队系统主要有：X/Y/Z，其中X表示到达时间间隔的分布，Y表示服务时间的分布，Z表示并列的服务设备的数目。表示相继到达的时间间隔或服务时间的分布的符号是： M——负指数分布，D——确定性，Ek——k阶Erlang，GI——相互独立的一般随机分布，G——一般的随机分布。 例如：M/M/1表示达到时间间隔为负指数分布，服务时间为负指数分布，单服务设备的排队系统。 这里我们用静态仿真的思想来实现M/M/1仿真。在排队系统中的每一个动态实体的状态可以有三个量来反映：与前一个实体到达的时间间隔，在排到自己服务前的等待时间以及服务时间。其中服务时间和到达时间间隔服从指数分布，不受别的因素的影响。开始服务前的等待时间则受到排在前面的动态实体的状态的影响。其更新算法如下： 即：如果某个实体到达以后，发现处在它前面的动态实体已经结束服务，所以这个实体就不用等待，直接接受服务；反之，处在它前面的动态实体如果没有结束服务（包括没有开始服务），则这个实体的等待时间就是它前一实体结束服务的时刻减去它到达的时刻。 5、如何得到每个顾客的到达时刻，服务时间，等待时间和离开时刻； 到达时间=前面各个到达时间之和； 服务时间就是负指数随机生成的时间； 等待时刻：如果前一个人的离开时间小于这个人的到达时间，等待时间=0； 如果不是，则等待时间=该人的离开时间-他的到达时间-服务时间 6、如何排队，排队的主要算法思想？ 排队就是来到的人数多于离开的人数； 如果下一个人到达时前一个人依旧在接受服务，则此人就要排队。 7、如何求队长？以及最大的队长？ 假设以5分钟为一个时间段，则在第5分钟时用这5分钟内来到的人数减去这5分钟内离开的人数即是排队人数 8、如何求平均等待时间？ 求平均等待时间首先要求出总的等待时间与接受服务的人数； 总的等待时间=每个人的等待时间之和；接受服务的人数由时间540分钟来控制，如果在540分钟之后才到达的人则不再算入接受服务的人数之内。 9、用C语言如何将得到的数据输出到文件？ 在C语言中用fopen函数打开文件，然后把数据输出比如用fprintf函数，最后fclose。 利用ofstream fcout(“d:arr_time.txt”);语句来实现C++中的输出文件 10、如何用已学的数学语言程序（如：Mathematica, Matlab）把C语言得到的数据文件画出其相应的图像？ 11、如果是两个窗口的服务系统，则该怎么修改程序？ 12、如果到达时间间隔，服务时间服从泊松分布或者其他分布，该程序该如何改进？ 二、数据结构课程设计题目 单窗口的排队模型的数值仿真（参考课本上第四章的离散事件模拟）要求如下：（1）要求相邻两个顾客的到达时间间隔服从负指数分布；且每个顾客接受服务的时间也服从负指数分布； （2）求出各个时刻的队长（以五分钟为一时间单位，即求零时刻的队长，五分钟时的队长，十分钟时的队长，依次类推）； （3）一个工作日内的顾客总数，约定8：30上班，17：30下班，中午不休息；（4）求平均等待时间（顾客总等待时间除以总人数）； （5）画出顾客的到达，离开图像（横坐标是顾客图，纵坐标是到达时刻，和离开时刻）； （6）画出队长变换图像（横坐标是时刻图，纵坐标是队长个数）；（7）求出一个工作日内的最大队长； 三、设计思路： 1）把8：:30记做第0分钟，17:30记做第540分钟。 2）首先利用C++随机生成200个服从负指数分布的到达时间与200个服务时间 然后根据随机生成的数计算到达的时刻，即到达时间的逐步加和，然后计算离开的时刻； 3）根据到达时刻与离开时刻来计算等待时刻，于是便可得到平均等待时间； 同时根据这两个时刻求出每5分钟到达人数与离开的人数，于是便得出每5分钟的队长，同时也可求出最大队长。4）再利用MATLAB画出相应的图像。 四、算法描述： 1）首先将8:30这个时刻化为0时刻，17:30化为第540分钟这个时刻，全体单位为分钟。 2）定义到达时间间隔arr_time[200]，服务时间ser_time[200]，到达时刻arr_time1[200],离开时间lea_time[200],等待时间sta_time[200],离开人数lea_num[200],到达人数arr_num[200]等变量。3）根据负指数函数 来利用C++程序生成随机到达时间间隔与服务时间。 4）利用到达时刻与离开时刻之间的关系来求出等待时间。同时将这540分钟划分为5分钟间隔的108个时间段来求出在每个时间段到达人数与离开人数，再求出队长。 5）利用已知的服务人数，平均到达时间与平均离开时间来做出图像。（借助MATLAB软件。） 五、总结 （1）求出各个时刻的队长（以五分钟为一时间单位，即求零时刻的队长，五分钟时的队长，十分钟时的队长，依次类推）；见程序清单中数据部分对长。（2）求平均等待时间（顾客总等待时间除以总人数）；根据程序可得，平均等待时间为21.6分钟。 （3）画出顾客的到达，离开图像（横坐标是顾客图，纵坐标是到达时刻，和离开时刻）； ***0100806040200 0Arrive curveleave curve***600 （6）画出队长变换图像（横坐标是时刻图，纵坐标是队长个数）； 25Queue Length Curve 20151050 ***0600 （7）求出一个工作日内的最大队长： 最大对长为16个人在排队。 六、程序清单： 求随机产生负指数 #include #include void main(){ long int i,k;double m,n;//m,n控制时间间隔 double r;double a,s,sum;//arr为到达时间，ser为服务时间 double LAM=1.2; //f(x)=LAM*exp(-LAM*x);double arr_time[200];double ser_time[200];ofstream fcout(“d:arr_time.txt”);ofstream fscout(“d:ser_time.txt”);m=2.0;n=5.0;srand((unsigned)time(NULL)); k=0;loop: r=((double)rand()/((double)(RAND_MAX)+(double)(1))); a =-log(r)/LAM;if(a >= m && a <= n){ arr_time[k]=a; k++;};if(k < 200)goto loop; // 产生200个指数分布随机数 for(i=0;i<200;i++){ fcout< //cout< if(i!=0 && i%5==0) //cout< fcout< s =-log(r)/LAM;if(s >= m && s <= n){ ser_time[k]=s;k++;};if(k < 100)goto loop1; // 产生200个指数分布随机数 m=3.0;n=5.5; srand((unsigned)time(NULL));k=100;loop2: r=((double)rand()/((double)(RAND_MAX)+(double)(1))); s =-log(r)/LAM;if(s >= m && s <= n){ ser_time[k]=s;k++;};if(k < 200)goto loop2; // 产生200个指数分布随机数 for(i=0;i<200;i++){ fscout< //cout< if(i!=0 && i%5==0) //cout< fscout< #include double sta_time[200];//等待时间 double arr_time[200];//随机生成到达时间 double ser_time[200];//随机生成服务时间 double arr_time1[200];//到达时间 ifstream fcin(“d:arr_time.txt”);ifstream fscin(“d:ser_time.txt”);ofstream fcout(“d:arr_time1.txt”);ofstream flcout(“d:lea_time.txt”);ofstream fscout(“d:sta_time.txt”); //求到达的时间 for(i=0;i<200;i++){ fcin>>arr_time[i]; arr_time1[i]=arr_time[i];} double sum=0.0;for(i=0;i<200;i++){ sum+=arr_time1[i]; arr_time1[i]=sum;} for(i=0;i<200;i++){ fcout< if(i!=0 && i%5==0) fcout< //求离开时间 fscin>>ser_time[0];lea_time[0]=arr_time1[0]+ser_time[0];for(i=1;i<200;i++){ fscin>>ser_time[i]; if(lea_time[i-1]>arr_time1[i]) {lea_time[i]=lea_time[i-1]+ser_time[i];} else {lea_time[i]=arr_time1[i]+ser_time[i];} } for(i=0;i<200;i++){ flcout< if(i!=0 && i%5==0) flcout< sta_time[i]=lea_time[i]-arr_time1[i]-ser_time[i];// if(sta_time[i]<0) { sta_time[i]=0; } } for(i=0;i<200;i++){ fscout< if(i!=0 && i%5==0) fscout< sta_sum+=sta_time[i];} //求平均等待时间 double ave;int peo_sum;for(i=0;i<200;i++){ if(lea_time[i]<540) peo_sum=i;} cout<<“总的服务人数为：”< 求离开人数和到达人数 #include #include int i,j; int arr_num[200];//到达人数arr int lea_num[200];//lea离开人数 int arr_jian=0;//时间间隔 double arr_time1[200];double lea_time[200];int peo_sum;int count=0;int count1=0;ifstream fcin(“d:arr_time1.txt”);ifstream flcin(“d:lea_time.txt”);ofstream fcout(“d:arr_num.txt”);ofstream flcout(“d:lea_num.txt”);for(i=0;i<200;i++){ fcin>>arr_time1[i]; flcin>>lea_time[i];} for(i=0;i<200;i++){ if(lea_time[i]<540) peo_sum=i;} while(arr_jian<540){ for(i=0;i { if(arr_time1[i]>arr_jian) { arr_num[count]=i; count++; //cout< break; } } for(j=0;j { if(lea_time[j]>arr_jian) { lea_num[count1]=j; count1++; break; } } arr_jian=arr_jian+5;} for(i=0;i<108;i++){ fcout< //cout< if(i!=0 && i%5==0) //cout< fcout< for(i=0;i<108;i++){ flcout< //cout< if(i!=0 && i%5==0) //cout< flcout< 求对长 #include int i;int max;int que[200];int arr_num[200];int lea_num[200];ifstream fcin(“d:arr_num.txt”);ifstream flcin(“d:lea_num.txt”);ofstream fcout(“d:que.txt”); for(i=0;i<200;i++){ fcin>>arr_num[i]; //cout< flcin>>lea_num[i]; //cout< for(i=0;i<200;i++){ que[i]=arr_num[i]-lea_num[i]; //cout< } for(i=0;i<200;i++){ fcout< if(i!=0 && i%5==0) { fcout< } } max=que[0];for(i=1;i<200;i++) { if(que[i]>max) { max=que[i]; //cout< } } cout<<“最大对长是”< 画图: function[maxque,mwait_t,mstay_t,queue_l,use_rate]=MM1queue(mean_arr,mean_lea,peo_num)status=zeros(3,peo_num); %用一个3行矩阵表示每个顾客的状态; %到达时间间隔，服务时间，等待时间;status(1,:)=exprnd(mean_arr,1,peo_num); %按照指数分布随机生成各顾客的到达间隔;status(2,:)=exprnd(mean_lea,1,peo_num); %按照指数分布随机生成各顾客的服务时间;for i=2:peo_num if status(1,i)<=status(2,i-1)+status(3,i-1) status(3,i)=status(2,i-1)+status(3,i-1)-status(1,i); else status(3,i)=0; end; %对状态进行更新； end;arr_time=cumsum(status(1,:));status(1,:)=arr_time;lea_time=sum(status);stairs([0 arr_time],0:peo_num); %绘出各顾客的到达时间图; hold on;stairs([0 lea_time],0:peo_num,'r'); %绘出各顾客的离去时间图;legend('Arrive curve','leave curve',0)hold off figure;plot(1:peo_num,status(3,:),'r:',1:peo_num,status(2,:)+status(3,:),'k-'); %绘出每个顾客的等待时间和停留时间;legend('Wait Time','Stay Time',0);n1=1;n2=1;mstay_t=(sum(status(2,:))+sum(status(3,:)))/peo_num;mwait_t=mean(status(3,:)); %求平均停留时间和等待时间;queue_num=zeros(1,2*peo_num+1);queue_time=zeros(1,2*peo_num+1);n3=1; %while循环求每个时间队列的长度;while n1<=peo_num n3=n3+1; if arr_time(n1) queue_num(1,n3)=n1-n2+1; queue_time(1,n3)=arr_time(n1); n1=n1+1; else queue_num(1,n3)=n1-n2-1; queue_time(1,n3)=lea_time(n2); n2=n2+1; end;end;while n2<=peo_num n3=n3+1; queue_num(1,n3)=peo_num-n2; queue_time(1,n3)=lea_time(n2); n2=n2+1;end;figure;stairs(queue_time,queue_num,'k'); %绘出队列长度的时间变化曲线, stairs 是Matlab的函数 legend('Queue Length Curve',0);hold off;temp=diff(queue_time);overtime=max(queue_time);queue_l=sum(temp.*queue_num(2:(2*peo_num+1)))/overtime;use_rate=sum(temp(find(queue_num)))/overtime;maxque=max(queue_num);% 最大队长 在MATLAB中命令窗口中输入MM1queue(2.86,3.22,175)数据结果： 随机到达时间arr_time 2.2218 2.91038 2.70151 3.20392 2.20729 2.23954 2.27037 2.12161 2.97105 2.59537 2.05195 2.33276 2.40885 2.54536 3.18395 4.34619 2.9621 4.03687 2.56005 4.3556 2.59767 2.6854 2.2156 2.35007 2.01546 3.16558 2.51725 2.4227 3.00499 2.68796 2.57445 2.29238 2.04275 3.56593 4.12181 3.14539 4.60806 2.85305 2.18215 4.15836 2.75386 2.45691 3.15095 3.84449 3.29556 2.35349 2.88082 2.96656 2.60517 3.09175 3.77562 2.12649 2.17347 2.28761 2.91709 2.59767 2.20084 3.64077 2.09167 2.30401 2.89137 2.78563 2.35564 2.60401 3.47721 2.31212 2.2892 2.26189 2.71001 3.23541 3.15543 4.04989 2.33905 2.60575 2.93069 2.63466 2.33025 2.67211 2.13304 2.46765 2.01119 2.66026 2.17867 4.26591 2.56115 2.84451 3.37485 2.22326 2.3109 3.08451 2.75872 3.02393 2.32155 2.37607 2.43489 3.70764 3.07631 2.56943 2.81941 2.81567 2.18215 3.78511 2.72393 2.02062 2.28013 2.03219 2.9324 4.02088 2.83606 2.01804 2.82241 2.23062 2.38448 2.15369 4.07996 2.02407 2.77847 2.93584 4.92381 4.07996 2.52143 2.10523 3.29291 2.34922 2.60807 2.83989 3.77091 2.4652 2.12096 2.36601 4.23257 2.29039 2.03278 3.42756 3.04233 2.80972 4.46149 2.04867 3.6673 2.04363 3.56409 4.8267 4.40435 3.60347 2.01375 4.41955 2.28406 2.49971 2.85853 2.11547 2.29079 2.2037 3.0078 2.43726 2.43963 3.82172 2.26189 3.14207 3.02297 2.39612 2.26381 3.59773 2.454 4.98197 3.60539 3.04233 3.21228 2.48553 2.16591 2.17244 2.25882 2.11773 3.77326 2.1113 3.15319 2.4011 2.66648 3.58261 3.36182 2.74012 2.16046 2.53464 2.21742 2.48754 2.86484 2.45837 2.4213 2.81047 4.02405 2.08667 2.24179 2.17971 3.1465 2.96925 2.07709 2.6139 3.48217 4.50565 3.25667 2.71528 随机服务时间ser_time 1.36266 1.25234 1.19953 1.81288 1.7025 1.49777 1.18475 1.2005 2.2218 2.91038 1.69353 1.06181 1.95277 1.86629 1.35603 1.36501 1.98628 1.05845 1.48635 2.70151 1.56285 1.7392 1.00964 1.69024 1.23548 1.68311 3.20392 2.20729 2.23954 1.0431 1.986 1.09644 2.27037 1.53367 2.12161 2.97105 1.68177 2.59537 2.05195 1.54594 1.24156 1.42946 2.33276 1.06994 2.40885 1.9069 2.54536 3.18395 4.34619 2.9621 1.09313 4.03687 2.56005 1.01332 1.97996 1.76143 1.26501 1.34689 1.66416 4.3556 1.6471 1.46631 2.59767 2.6854 1.92952 1.51985 1.85138 1.04044 2.2156 1.30726 1.1663 1.16661 5.21173 2.35007 1.3357 1.00973 2.01546 3.16558 2.51725 1.27905 2.4227 1.04284 1.69508 1.63761 1.13783 1.05052 1.94433 1.53127 3.00499 2.68796 2.57445 2.29238 1.40015 1.2112 1.64527 2.04275 1.29598 1.29286 3.56593 1.07538 3.20392 3.18395 4.34619 4.03687 4.3556 5.21173 3.16558 3.00499 3.56593 4.12181 3.14539 4.60806 4.15836 3.15095 3.84449 3.29556 5.29513 3.09175 3.77562 3.64077 3.47721 3.23541 3.15543 4.04989 4.26591 3.37485 3.08451 3.02393 3.70764 3.07631 3.78511 4.02088 4.07996 4.92381 4.07996 3.29291 3.77091 4.23257 3.42756 3.04233 4.46149 3.6673 3.56409 4.8267 4.40435 3.60347 4.41955 3.0078 3.82172 3.14207 3.02297 3.59773 4.98197 3.60539 3.04233 3.21228 3.77326 3.15319 3.58261 3.36182 5.0445 4.02405 3.1465 3.48217 4.50565 3.25667 4.85208 4.16211 4.13261 3.21952 3.46087 3.74548 4.5463 3.72969 3.29423 3.0804 3.08657 3.47556 4.09022 3.17586 5.29513 3.75694 3.74548 3.30222 3.01725 3.18627 3.40305 4.12539 3.49556 3.02777 3.87053 3.39703 3.51433 3.67983 3.27072 4.11115 4.22444 4.08337 3.37339 5.03375 到达时刻：arr_time1 2.2218 5.13218 7.83369 11.0376 13.2449 15.4844 17.7548 19.8764 22.8475 25.4428 27.4948 29.8276 32.2364 34.7818 37.9657 42.3119 45.274 49.3109 51.8709 56.2265 58.8242 61.5096 63.7252 66.0753 68.0907 71.2563 73.7736 76.1963 79.2012 81.8892 84.4637 86.756 88.7988 92.3647 96.4865 99.6319 104.24 107.093 109.275 113.434 116.187 118.644 121.795 125.64 128.935 131.289 134.17 137.136 139.741 142.833 146.609 148.735 150.909 153.196 156.113 158.711 160.912 164.553 166.644 168.948 171.84 174.625 176.981 179.585 183.062 185.374 187.664 189.925 192.635 195.871 199.026 203.076 205.415 208.021 210.952 213.586 215.917 218.589 220.722 223.189 225.201 227.861 230.039 234.305 236.867 239.711 243.086 245.309 247.62 250.705 253.463 256.487 258.809 261.185 263.62 267.327 270.404 272.973 275.793 278.608 280.79 284.575 287.299 289.32 291.6 293.632 296.565 300.586 303.422 305.44 308.262 310.493 312.877 315.031 319.111 321.135 323.913 326.849 331.773 335.853 338.374 340.48 343.773 346.122 348.73 351.57 355.341 357.806 359.927 362.293 366.525 368.816 370.849 374.276 377.318 380.128 384.59 386.638 390.306 392.349 395.913 400.74 405.144 408.748 410.762 415.181 417.465 419.965 422.823 424.939 427.23 429.433 432.441 434.878 437.318 441.14 443.402 446.544 449.567 451.963 454.227 457.824 460.278 465.26 468.866 471.908 475.12 477.606 479.772 481.944 484.203 486.321 490.094 492.205 495.359 497.76 500.426 504.009 507.371 510.111 512.271 514.806 517.023 519.511 522.376 524.834 527.255 530.066 534.09 536.176 538.418 540.598 543.744 546.714 548.791 551.405 554.887 559.393 562.649 565.364 离开时刻：lea_time 3.58446 6.38452 9.03322 12.8505 14.9474 16.9822 18.9396 21.0769 25.0693 28.3532 30.0467 31.1086 34.1892 36.6481 39.3217 43.6769 47.2603 50.3693 53.3573 58.928 60.4909 63.2488 64.7348 67.7655 69.3262 72.9394 76.9775 79.1848 81.4408 82.9323 86.4497 87.8525 91.0692 93.8984 98.6081 102.603 105.922 109.688 111.74 114.979 117.429 120.074 124.128 126.71 131.344 133.251 136.715 140.32 144.666 147.628 148.722 152.772 155.332 156.345 158.325 160.472 162.177 165.9 168.308 173.304 174.951 176.417 179.579 182.27 184.992 186.894 189.515 190.966 194.851 197.178 200.193 204.243 210.627 212.977 214.313 215.322 217.932 221.754 224.271 225.551 227.973 229.016 231.735 235.943 238.004 240.762 245.03 246.84 250.625 253.393 256.038 258.78 260.209 262.396 265.265 269.37 271.7 274.266 279.358 280.434 283.994 287.759 292.106 296.142 300.498 305.71 308.875 311.88 315.446 319.568 322.713 327.322 331.48 334.631 338.475 341.771 347.066 350.158 353.933 357.574 361.051 364.287 367.442 371.492 375.758 379.133 382.217 385.241 388.949 392.025 395.81 399.831 403.911 408.835 412.915 416.208 419.979 424.211 427.639 430.681 435.143 438.81 442.374 447.201 451.605 455.209 459.628 462.636 466.458 469.6 472.623 476.22 481.202 484.808 487.85 491.062 494.836 497.989 501.572 504.933 509.978 514.002 517.148 520.631 525.136 528.393 533.245 537.407 541.54 544.759 548.22 551.966 556.512 560.242 563.536 566.616 569.703 573.178 577.269 580.444 585.74 589.496 593.242 596.544 599.561 602.748 606.151 610.276 613.772 616.799 620.67 624.067 627.581 631.261 634.532 638.643 642.867 646.951 650.324 655.358 到达人数：peo_num 0 1 3 5 8 9 12 14 15 16 18 19 21 23 25 27 29 31 33 34 36 39 40 42 43 45 47 49 50 52 54 56 58 60 62 64 65 68 69 71 74 76 78 80 82 84 86 87 89 91 93 95 96 98 100 102 104 106 107 109 111 113 115 117 118 119 121 123 125 126 129 130 132 134 135 137 138 140 141 142 144 145 148 150 152 154 155 157 159 161 162 163 165 166 167 169 170 171 173174 175 177 离开人数：lea_num 0 1 3 5 7 8 10 13 15 16 17 19 20 23 25 26 28 30 32 34 35 38 40 41 43 44 46 47 49 51 52 55 57 59 61 63 65 67 69 70 72 75 77 79 82 83 85 86 88 90 92 94 96 98 99 101 102 103 104 105 107 108 110 111 112 114 115 116 117 119 120 122 123 124 127 129 130 132 133 134 135 137 138 139 140 142 143 144 147 148 150 151 152 154 155 157 158 160 161 162 队长que 0 0 0 0 1 1 2 1 0 0 1 0 1 0 0 1 1 1 1 0 1 1 1 0 1 0 1 2 1 1 2 1 1 1 1 1 0 1 0 1 0 2 1 1 1 0 1 1 1 1 1 1 0 0 1 1 2 3 3 4 4 5 5 6 6 5 6 7 8 7 9 8 9 10 0 10 9 10 9 9 10 10 11 12 13 14 13 14 15 16 15 15 15 15 0 0 0 0 0 0 0 0 605040302010Wait TimeStay Time***401601800 0 计算机科学与工程系 数据结构课程设计报告 课程设计题目 迷宫 航班信息查询系统 学 号 姓 名 班 级 专 业 网络工程 完 成 时 间 2013-1-4 指 导 教 师 数据结构课程设计 迷宫 题目一 1.设计内容 1.1问题描述 求迷宫从入口到出口的所有路径。1.2设计要求 1．迷宫中不能使用递归算法查找路径。2．试探方向限定为上、下、左、右四个方向。3．迷宫采用随机生成和手工生成两种方式。4．生成从迷宫入口到出口的最短和最长路径。5．迷宫的入口和出口由键盘输入。 1.3开发环境 Visual C++6.0的集成化环境 1.4研究思路 对这样的矩形迷宫，可以用N*M的矩阵来描述，N和M分别代表迷宫的行数和列数。这样，迷宫中的每一个位置都可以用行号和列号来指定。从入口到出口的路径则是由一个位置构成的，每个位置上都没有障碍，且每个位置（第一个除外）都是前一个位置的东、南、西或北的邻居。为了描述迷宫中位置（i,j）处有无障碍，规定：当位置（i,j）处有一个障碍时，其值为1，否则为0。 经分析，一个简单的求解方法是：从入口出发，沿某一方向进行探索，若能走通，则继续向前走；否则沿原路返回，换一方向再进行搜索，直到所有可能的通路都探索到为止。即所谓的回溯法。 2.设计步骤 2.1 需求分析 （1）题目：迷宫的生成与路由。生成一个N*M（N行M列）的迷宫，0和 1-1数据结构课程设计 迷宫 在该程序中，首先进入的是菜单选择，在菜单中有3种选择，选1是手动输入迷宫函数；选2是随机自动生成迷宫；选3是退出程序。在手动生成迷宫时，有两种输出方式，一是矩阵输出，二是图形输出。在矩阵输出时，直接将数组中的数进行输出，在图形输出时，则要判断该点的情况，然后输入迷宫的出入口，再调用mgpath（）函数进行判断是否存在路径，如果存在则将路径经过的点进行输出，并且将经过的点进入到辅助数组中（辅助数组是辅助图形界面的输出），并且将辅助数组初始为1，辅助数组中点为路径的重新赋值为0，然后根据情况输出图形界面。在自动生成迷宫时，用到了c语言随机函数，对于其它问题，和手动情况基本相同。 2.3 详细设计（1）主菜单伪代码： while(flag1){ } {shuru();//输入行列数 printf(“手动建立迷宫矩阵(0表示可通1表示障碍):n”);for(i=1;i<=m;i++) for(j=1;j<=n;j++)scanf(“%d”,&mg[i][j]);showplay(mg);// 迷宫输出 churukou();//迷宫出入口的输入 x=Mazepath(mg);// 判断路径函数 数据结构课程设计 迷宫 和“class ‘maze’has an illegal zero-sized array”两行错误。双击错误信息，找到出错的程序段，经过查阅资料发现，在利用顺序栈时，没有定义顺序栈的向量空间大小，导致程序出错。但不要对向量空间定义过大，否则会浪费空间。 （2）算法的时空分析： 由于链栈实际上是运算受限制的单链表。所以取栈顶元素运算的算法、置空栈运算的算法执行时间与问题的规模无关，则该算法的时间复杂度为O(1)；而其入栈运算的算法与出栈运算的算法相当于在链表的表尾进行插入和删除操作，不需要移动元素，时间复杂度也为O（1）。建立迷宫矩阵的时间复杂度为O（x*y）。在查找路径的过程中，最坏的情况下可能要考察每一个非障碍的位置。因此，查找路径的时间复杂度应为O（unblocked）。 链栈的入栈算法、出栈算法、取栈顶元素算法、置空栈算法执行时所需要的空间都是用于存储算法本身所用的指令、常数、变量，各个算法的空间性能均较好。只是对于存放顺序栈的向量空间大小的定义很难把握好，如果定义过大，会造成不必要的空间浪费。所以在定义时要慎重考虑。 3.用户使用说明 运行该程序，运行的界面的会出现菜单界面，然后用户可根据界面的提示进行相应的操作，生成迷宫的方式有两种方式，手动生成和自动生成，手动生成时、，用户可根据自己的要求输入迷宫的格式，还需输入相应的入出口，确认程序就会生成相应的路径图形；自动生成只需输入所需的行数和列数，就会生成迷宫，接下来的操作和手动操作相同了。 图数据结构课程设计 迷宫 图1-2 图1-3 退出 5.总结与心得体会 本次课程设计过程中由于掌握的知识不牢固，在编程序的过程中得到了同学的帮助和指导，在此表示感谢。课程设计的过程中，遇到了一些问题，大部分是课本中的知识掌握的不牢固，还有就是在以前学习C++的过程中相关的知识掌握的不够全面。在以后的学习过程中，自己一定要把各种知识掌握牢固。 { } mg[i][j]=1;//初始化 矩阵,将最外围置为1 printf(“n输入迷宫入口：n”);scanf(“%d%d”,&x1,&y1);printf(“输入迷宫出口：n”);scanf(“%d%d”,&x2,&y2); }mlink;mlink *stack;//定义一个栈 int m,n,x1,x2,y1,y2;//定义全局变量 } void showplay(int mg[][M+2])//迷宫输出 { n“); for(i=1;i<=m;i++){ printf(”n“);for(j=1;j<=n;j++) printf(”%d “,mg[i][j]); int i,j; printf(”迷宫矩阵如下(0可通)：printf(“输入行数：n”);scanf(“%d”,&m);printf(“输入列数：n”);scanf(“%d”,&n);数据结构课程设计 迷宫 } } printf(“n迷宫图形如下(白色for(i=1;i<=m;i++){ } printf(”n“);for(j=1;j<=n;j++){ } if(mg[i][j]==0)printf(” if(mg[i][j]==1)printf(“ if(mg[stack->row][stack->col+1]== p->next=stack; stack=p;{ p=(mlink 可通)：n”);0)//下面位置可通 *)malloc(sizeof(mlink)); p->row=stack->row;p->col=stack->col+1;□“);//为0的输出□ ■”);//为1的输出■ //入栈 mg[stack->row][stack->col]=1;//将 } else 访问过的标记为1 int Mazepath(int mg[][N+2]){ mlink *p;if(mg[x1][y1]==0){ p=(mlink p->row=x1;p->col=y1;p->next=NULL;stack=p; //将入口 mg[stack->row][stack->col]=1;/while((!(stack->row==NULL& if(mg[stack->row][stack->col-1]==0)//上面可通 //入栈 stack=p; p->next=stack; { p=(mlink *)malloc(sizeof(mlink)); *)malloc(sizeof(mlink)); p->row=stack->row;p->col=stack->col-1;放入堆栈 /标志入口已访问 &stack->col==NULL))&&(!(stack->row==x2&&stack->col==y2)))//循环条件直到找到输入的出口 { mg[stack->row][stack->col]=1;//将 访问过的标记为1 数据结构课程设计 迷宫 void tonglu()//将坐标的顶点输出 { 始化 printf(“(%d%3d)n”,q->row,q->col); 情况 else printf(“□”);//0的 } q=stack;{ } for(i=0;i for(j=0;j = while(q!=NULL)//循环条件 q=q->next;for(j=0;j 情况 } void create(int mg[][N+2])//创建和菜单 { int i,j,x,choice,flag1=1;chushi();while(flag1){ } printf(“n”);printf(“所有通道为（由下而q=stack;{ 上）：n”);while(q!=NULL)//循环条件 printf(“ ## printf(”# n“); *********选择菜单********** #n”); printf(“ ## printf(”输入选项：“);scanf(”%d“,&choice);switch(choice){ case 1://手动建立迷宫 { shuru(); printf(”手动建立for(i=1;i<=m;i++) n“); printf(”# 1-手动生成迷 宫 2-自动生成迷宫 3-退出 #n“);0;//将路径中的点赋给辅助数组a 形的界面输出 迷宫矩阵(0表示可通1表示障碍):n”); for(j=1;j<=n;j++)scanf(“%d”,&mg[i][j]); 数据结构课程设计 航班信息查询与检索系统 题目二 1.设计内容 1.1问题描述 设计一个航班信息查询系统，提供信息的管理和使用功能，管理包括更新、添加、删除功能。 1.2设计要求 （1）原始信息存储在文件中，记录不少于50条。（2）用户界面至少包括以下功能： 创建 修改（插入、添加、删除、更新） 查询 浏览 退出管理系统（3）航班信息包括： 航班号：字符序列，具体字符表达的意思上网查询 起点站和终点站：字符串 班期：指一周中哪些天有航班 起飞时间：可将时间定义成一个时、分组成的序列 到达时间：可将时间定义成一个时、分组成的序列 机型：字符序列，具体字符表达的意思上网查询 票价：整型数，具体值可上网查询 （4）创建是指从文件中读取数据，并存入所定义的顺序表中。 （5）可按航班号、起点站、终点站、起飞时间、到达时间等进行查询。查询时要用到顺序查找、二分查找方法。输出查询结果时必须排序。 （6）可按航班号、起点站、起飞时间、票价进行删除和更新操作，删除的记录存入另外的文件中，作为日志文件保存。 （7）作插入操作前，先对信息按起点站进行排序。新记录插入为起点站相同的最后一条记录。 数据结构课程设计 航班信息查询与检索系统 typedef struct node { Time rh;Time lv;}Pnode;（2）飞机结构体： struct Plane { };（3）静态链表： typedef struct Sqlist { int length;struct Plane *plane;char key[10],sted[20],sche[10];Time rh,lv;int price;}Sqlist;2.3 详细设计（1）主函数： do{printf(“* * * * * * * * * * * * * 航班查询系统* * * * * * * * * * * * *n”); printf(“* 1.创建 2.修改 3.查询 4.浏览 5.表长 6.文件 0.退出 *n”); printf(“* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *n”); scanf(“%d”,&opt);switch(opt){ case 1:Initlist(L);break; case 2:handle(L);break; case 3:search(L);break; case 4:print(L);break;case 5:Get_Sq(L);break;case 6:File(L);break; 数据结构课程设计 航班信息查询与检索系统 } }while(opt!=0);} （4）文件操作： void File(Sqlist &L){ int ch;do{ printf(“* * * * * * * * * * * * * * * * * * * * * * * * *n”); printf(“* *n”); printf(“* 1.保存信息到文件 2.从文件读取信息 0 退出 *n”); printf(“* *n”); printf(“* * * * * * * * * * * * * * * * * * * * * * * * *n”); printf(“请输入选项n”); scanf(“%d”,&ch); switch(ch) { case 1:SaveList(L);break; } }while(ch!=0);case 2:ReadList(L);break; case 0:printf(“退出！n”);break;} （5）浏览信息：就是循环使用输出函数，在此就不必多说了 2.4 调试分析 （1）在课设过程中，遇到问题时，通过与同学、老师交流，在图书馆查阅资料，使问题得以解决。 （2）算法中有许多不是很优化的地方。3.用户使用说明 程序运行后用户根据提示输入要进行的操作选项（应先选择创建选项，这样可以直接读取保存好的文件），然后选择要进行的操作选项。由于主菜单中有修改、查询和浏览项目，每个项目又有各自的子菜单，所以在进行管理和使用时要注意输入的元素是否正确，需按照提示输入。输入操作元素时，元素之间以空格隔开。程序将按输入的操作元素找到相应的算法，然后进行处理，然后将结果打 数据结构课程设计 航班信息查询与检索系统 图2-2 查询信息 图2-3插入 图2-4删除 数据结构课程设计 航班信息查询与检索系统 时就需要重新写出一个子函数，哪怕这个子函数就是在原有的一个子函数的基础上改那么一丁点的地方，例如航班信息查询系统中的查询函数，其实每个子函数只是改了一下关键码而已。 6.附录 #include { } void search_key(Sqlist L)//按航班号查找 { 号：“); Time rh;Time lv; scanf(”%s“,n);int i; printf(”此航班的航班号，起点char n[20]; printf(“请输入要查找的航班 printf(”%dn“,L.length);//表长 }Time;typedef struct node { }Pnode;struct Plane { };typedef struct Sqlist { int length;struct Plane *plane;char key[10],sted[20],sche[10];Time rh,lv;int price; 终点，班期，起飞时间，到达时间，票价：n”); if(strcmp(L.plane[i].key,n)==0) ted，L.plane[i].sche,L.plane[i].lv.hour,L.{ for(i=L.length-1;i>=0;i--){ printf(“%s %s %s %d:%d % d:%d %dn”,L.plane[i].key,L.plane[i].s}Sqlist;int get_Sq(Sqlist &L){ } void Get_Sq(Sqlist &L)return L.length; plane[i].lv.min,L.plane [i].rh.hour,L.plane[i].rh.min,L.plane [i].price); 0数据结构课程设计 航班信息查询与检索系统 printf(“此航班的航班号，起点 ted，{ 终点，班期，起飞时间，到达时间，票价：n”); if(L.plane[i].lv.hour<=hour) ted，L.plane[i].sche,L.plane[i].lv.hour,L.{ for(i=L.length-1;i>=0;i--){ printf(“%s %s %s %d:%d % d:%d %dn”,L.plane[i].key,L.plane[i].s L.plane[i].sche,L.plane[i].lv.hour,L.plane[i].lv.min,L.plane [i].rh.hour,L.plane[i].rh.min,L.plane } void search(Sqlist L){ int i;do { printf(“* * * * * * * * * * * } } printf(”%s %s %s %d:%d %d:%d %dn“,L.plane[i].key,L.plane[i].s[i].price);plane[i].lv.min,L.plane [i].rh.hour,L.plane[i].rh.min,L.plane } void search_rh(Sqlist L){ int hour;printf(”请输入你所要求的最scanf(“%d”,&hour);printf(“此航班的航班号，起点 } } [i].price); * * * * * * * * * * * * * ** * * * * * * * * * * * * * * *n”); printf(“* 1.航班号查询 2.起点终点查询 3.班期查询 4.起飞时间查询 5.到达时间查询 0.退出 *n”); printf(“* * * * * * * * * * * * * * * * * * * * * * * * ** * * * * * * * * * * * * * * *n”); scanf(“%d”,&i); switch(i) { case 晚时间：“);终点，班期，起飞时间，到达时间，票价：n”); if(L.plane[i].rh.hour<=hour)for(int i=L.length-1;i>=0;i--){ 1:search_key(L);break; 2数据结构课程设计 航班信息查询与检索系统 n“); } else { } printf(”查找不成功。 i--;if(i==0) { char c[20]; printf(“输入修改后的scanf(”%s“,c); 内容：”); strcpy(L.plane[i].sche,c); printf(“修改成功！n”);}break;{ int a,b; printf(“输入修改后的int opt;printf(”选择修改对象：“);scanf(”%d“,&opt);switch(opt){ case 1: printf(”修改成功！n“);printf(”修改成功！n“);{ char a[10];printf(”输入修改后的scanf(“%s”,a); case 4: 内容：“); char b[20];printf(”请输入修改后scanf(“%s”,b); scanf(“%d:%d”,&a,&b); L.plane[i].lv.hour=a;L.plane[i].lv.min=b;printf(“修改成功！n”);航班号：“); }break;{ int a,b; printf(”输入修改后的strcpy(L.plane[i].key,a);}break;{ case 5: case 2: 内容：“); scanf(”%d:%d“,&a,&b); L.plane[i].rh.hour=a;L.plane[i].rh.min=b;printf(”修改成功！n“);的内容：”);strcpy(L.plane[i].sted,b);}break; }break;{ int a; case 6: case 3: 4数据结构课程设计 航班信息查询与检索系统 *n“); printf(”* * * * * * * * * * * * * * * * * * * * * * * * *n“); printf(”请输入选项n“); scanf(”%d“,&ch); switch(ch) { case 1:SaveList(L);break;case 2:ReadList(L);break; L.plane[i].sche,&L.plane[i].lv.hour，&L.plane[i].lv.min,&L.plane [i].rh.hour,&L.plane[i].rh.min,&L.pl } void delet_Sq1(Sqlist &L){ char n[10];int i,j; printf(”请输入您要删除的航scanf(“%s”,n);if(L.length==0){ printf(“没有选项！n”);for(i=0;i L.length++; ane[i].price); case 0:printf(“退出！n”);break; } void Initlist(Sqlist &L)//插入存储 { “); 容：”);价n“); scanf(”%s%s%s%d:%d%d:%d%d“,L.plane[i].key,L.plane[i].sted, for(i=0;i 班期 起飞时间 到达时间 票scanf(”%d“,&n);L.length=0;L.plane=(Plane if(!L.plane)exit(0);printf(”请输入顺序表中的内 int i,n;printf(“输入表中航班的数量： } }while(ch!=0); 班号：”); if(strcmp(L.plane[i].key,n)==0) { printf(“所删除的班机*)malloc((n+10000)*sizeof(Plane));的信息：n”); printf(“n航班号 起点终点 printf(”%s %s %s %d:%d %d:% d %dn“,L.plane[i].key,L.plane[i].sted，L.plane[i].sche,L.plane[i].lv.hour,L.plane[i].lv.min,L.plane [i].rh.hour,L.plane[i].rh.min,L.plane [i].price); 6数据结构课程设计 航班信息查询与检索系统 n”);} printf(“无法打开文件！} }while(opt!=0); void insert_Sq(Sqlist &L){ 数量 价n”); for(i=0;i printf(“* * * * * * * * * * * scanf(”%s%s%s%d:%d%d:%d%d“,&L.plane[L.length].key,&L.plane[L.length].sted，&L.plane[L.length].sche,&L.plane[ { int a=get_Sq(L); printf(”请输入要添加班机的scanf(“%d”,&n); printf(“请输入要添加的班机printf(”n航班号 起点终点 int i,n; //n表示添加的fprintf(fp,“航班号：%sn起点站：%s 终点站：%sn班期：%dn起飞时间：%d:%d 到达时间：%d:%dn价格：%dnn”, p.key,p.sted,p.sche,p.lv.hour,p.lv.mi n“);} void delet_Sq(Sqlist &L){ int opt;do { fclose(fp);printf(”保存删除的信息成功。n,p.rh.hour,p.rh.min,p.price); 数量：“); 信息：n”); 班期 起飞时间 到达时间 票* * * * * * * * * *n“); printf(”* 1.航班号删除 printf(“* * * * * * * * * * printf(”输入你的选择：“);2.路线删除 0.退出 *n”);* * * * * * * * * * *n“); scanf(”%d“,&opt); switch(opt){ case 1:delet_Sq1(L);break; case 2:delet_Sq2(L);break; case 0:printf(”退出。} L.length].lv.hour,&L.plane[L.length].lv.min，&L.plane[L.length].rh.hour,&L.plan e[L.length].rh.min,&L.plane[L.length].price); } void handle(Sqlist &L){ } L.length++; n");break;第二篇：数据结构huffman编码作业报告
第三篇：数据结构课程设计报告
第四篇：数据结构课程设计报告
第五篇：数据结构课程设计报告
点击咨询 