《数据结构》 课程设计

分类：数据结构作者：编程之家用户
一.问题描述

题目4.赵斌是一个信管专业的学生，大学四年顺利毕业了。在毕业季，他也像其他学子一样，投身于求职大军，投出一份又一份求职简历，在苦苦地等待之后，他接到了中国移动通信公司广东分公司的面试通知书，通知他于本月1号10点到公司面试。当天，晴空万里，艳阳高照，他身着西装，高兴地早早来到公司楼下等待。10点钟整，他和其他新人一起，坐到公司的面试现场。他领取的一份程序设计题： 假如你是我公司一名客服技术人员，现请你选择自己熟悉的语言，来设计一个程序，管理客户向公司打进来的咨询电话。请事行分析使用方法和工具，说明自己的思路方法，写一份完整的程序，并实例测试。

二.问题分析

在现实生活中，排队叫号是经常发生的事情。从实习的题目看来，就是要求采用队列的逻辑结构及其物理结构，模拟日常生活中客服的接入情况。本次的课程设计其依据的主要相关知识是线性表、队列和函数模版等以及一些基础的C++编程语言知识。这里，我主要采用链队列相关的知识来完成本系统。

三．逻辑结构和存储结构设计

（一）、队列的定义

队列是只允许在一端进行插入操作，在另一端进行删除操作的线性表。允许插入（入队、进队）的一端称为队尾，允许删除（出队）的另一端称为队头。

队列中的元素之间不仅具有线性关系，而且具有先进先出的特性。

例如：按顺序入队：a1,a2,a3;；如果要删除元素，其出队的顺序是：a1,a3；

队列中的元素具有相同类型及先进先出特性，相邻元素具有前驱和后继的关系。

当客户打电话来咨询时，遇到多人同时需要办理业务，但是，考虑到客服人员不多，所以这里就要有一个先来后到的思想，即先进先出，刚好符合队列的逻辑思想，故而本系统采用队列的逻辑结构及其物理结构。

（二）、队列的顺序存储结构——循环队列

队列是特殊的线性表。 允许队列直接从数组中下标最大的位置延续到下标最小的位置，这个通过取模操比较容易实现，这种头尾相接的顺序存储结构称为循环队列。

队空和队满的判定方法：可以用一个数组的元素空间来实现队尾指针和队头指针相差1（类似于队满的临界状态）。

循环队列的实现：因为队列元素的数据类型不是很确定，这个时候我们还是要采用C++模版机制。其时间复杂度为O（1）。

（三）、循环队列的链接存储——链队列

为了使空队列和非空队列的操作一致，链队列也加上头结点。设置头指针指向链队列的头结点，队尾指针指向终端结点。

链队列的实现;同样的因为队列元素的数据类型不是很确定，这个时候我们还是要采用C++模版机制。其时间复杂度为O（1）。

四． 总体设计

1.系统流程图

2.系统概要分析图

五．算法设计

代码分析：

1.头文件（tel.h）

这里采用函数模版template<class DataType>。

Struct Node

node< DataType >*next;在头文件tel.h中定义结构体Node，其包含数据域DataType data;和指针域node< DataType >*next;指针。

2.无参构造函数

LinkQueue<DataType>::LinkQueue()

{

Node<DataType>*s = NULL;

s = new Node<DataType>;

s->next = NULL;

front = rear = s;

}

定义一个头结点，让头结点为空，front=rear=s这样队列就为空。

3．析构函数

template<classDataType>

LinkQueue<DataType>::~LinkQueue()

{

Node<DataType>*p = NULL;

while (front != NULL)

{

p = front->next;

delete front;

front = p;

}

}

析构函数可以释放存储空间，定义一个结点为空，其指针p所指向的头结点不为空时，就要进行删除操作，让不为空的头结点，指向新定义为空的指针P所指向的next域，即下一个空结点，删除不为空的头结点后，这个头结点被赋值为空指针P。

4.插入队列函数EnQueue()

voidLinkQueue<DataType>::EnQueue(DataType x)

{

Node<DataType>*s = NULL;

s = new Node<DataType>;

s->data = x;

s->next = NULL;

rear->next = s; rear = s;

}

template<classDataType>

定义一个新结点s为空，然后申请一个数据域为X的结点s，其nxet域为空，尾指针的next域被赋值为s，最后将结点s插入到队尾。

5.删除队列函数DeQueue()

DataTypeLinkQueue<DataType>::DeQueue()

{

Node<DataType>*p = NULL;

int x;

if (rear == front)throw"已经没有客户等候了";

p = front->next;

x = p->data;

front->next = p->next;

if (p->next == NULL)rear = front;

delete p;

return x;

}

6.取队头函数GetQueue()

template<classDataType>

DataTypeLinkQueue<DataType>::GetQueue()

{

if (front != rear)

return front->next->data;

}

template<classDataType>

7.判断是否为空值Empty()

intLinkQueue<DataType>::Empty()

{

if (front == rear)

return 1;

else

return 0;

}

六． 时间复杂度与空间复杂度分析

为了使空队列和非空队列的操作一致，链队列也加上头结点。设置头指针指向链队列的头结点，队尾指针指向终端结点。

链队列的实现;同样的因为队列元素的数据类型不是很确定，这个时候我们还是要采用C++模版机制。其时间复杂度为O（1）。空间复杂度为O（n）。

七． 程序运行结果

八．感想与收获

这个程序是基于课本队列那一章节的内容完成的，里面的客户排队其实就是运用了队列的原理。这让我体会到在生活之中处处都有它独特的逻辑与算法，即使是一个小小的客服，也会有很多的内容在里面。我记得有人说过一句话：“真正的科技就是让你感觉不到科技的存在。”是啊，一个真正好的，拥有良好用户体验的程序往往蕴含着紧密的逻辑结构。在这个程序里，我还加入了上个学期的struct结构用来储存客户资料，也算是温故知新吧。



九．附录（源程序）

头文件

#ifndef LinkQueue_H
#define LinkQueue_H

template<class DataType>
struct Node
{
	DataType data;
	Node<DataType>*next;
};
template<class DataType>
class LinkQueue
{
public:
	LinkQueue();
	~LinkQueue();
	void EnQueue(DataType x);
	DataType DeQueue();
	DataType GetQueue();
	int Empty();
private:
	Node<DataType>*front,*rear;
};
#endif
算法
<pre class="cpp" name="code">#include"LinkQueue.h"
template<class DataType>
LinkQueue<DataType>::LinkQueue()
{
	Node<DataType>*s = NULL;
	s = new Node<DataType>;
	s->next = NULL;
	front = rear = s;
}
template<class DataType>
LinkQueue<DataType>::~LinkQueue()
{
	Node<DataType>*p = NULL;
	while (front != NULL)
	{
		p = front->next;
		delete front;
		front = p;
	}
}
template<class DataType>
void LinkQueue<DataType>::EnQueue(DataType x)
{
	Node<DataType>*s = NULL;
	s = new Node<DataType>;
	s->data = x;
	s->next = NULL;
	rear->next = s; rear = s;
}
template<class DataType>
DataType LinkQueue<DataType>::DeQueue()
{
	Node<DataType>*p = NULL;
	int x;
	if (rear == front)throw"已经没有客户等候了";
	p = front->next;
	x = p->data;
	front->next = p->next;
	if (p->next == NULL)rear = front;
	delete p;
	return x;
}
template<class DataType>
DataType LinkQueue<DataType>::GetQueue()
{
	if (front != rear)
		return front->next->data;
}
template<class DataType>
int LinkQueue<DataType>::Empty()
{
	if (front == rear)
		return 1;
	else
		return 0;
}

主函数：
#include<iostream>
#include<string>
#include<iomanip>
using namespace std;
#include"LinkQueue.cpp"
struct info
{
char name[10];
int tel;
};
struct info data[50];
int n = 0;
int g = 1;
void show();
void main()
{
LinkQueue<int> Q;
int select;
do
{
system("cls");
cout << "|--- 欢迎致电123电话客服 ---|" << endl;
cout << "| 1、接入热线 |" << endl;
cout << "| 2、查询客服状态 |" << endl;
cout << "| 3、完成客户业务 |" << endl;
cout << "| 4、正在办理业务 |" << endl;
cout << "| 5、显示客户资料 |" << endl;
cout << "| 6、退出 |" << endl;
cout << "| 0、办理业务 |" << endl;
cin >> select;
switch (select)
{
case 0:
if (Q.Empty())
{
cout << "您好，客服mm为您服务" << endl;
try
{
n++;
cout << "\t姓名:";
cin >> data[n].name;
cout << "\t联系电话:";
cin >> data[n].tel;
cout << "操作完成！" << endl;
}
catch (char*wrong)
{
cout << wrong << endl;
}
}
else
cout << "客服正忙，请稍后..." << endl;
system("pause");
break;
case 1:
try
{
n++;
cout << "成功接入客服: " << endl;
cout << "您是今天的第" << n << "个客户""前面还有" << g - 1 << "个客户" << endl;
if (Q.Empty())
cout << "请按数字0办理业务" << endl;
else
cout << "请耐心等候..." << endl;
Q.EnQueue(g);
g++;
system("pause");
}
catch (char*wrong)
{
cout << wrong << endl;
}
break;
case 2:
cout << "查看对头元素:" << endl;
if (Q.Empty())
{
cout << "客户等待个数" << setw(24) << "正在办理业务客户号码" << setw(14) << "办理情况" << endl;
cout << setw(5) << 0 << setw(26) << "无客户办理业务" << setw(24) << "空闲等待中..." << endl;
}
else
{
cout << "客户等待个数" << setw(24) << "正在办理业务客户号码" << setw(14) << "办理情况" << endl;
cout << setw(5) << g - 1 << setw(22) << Q.GetQueue() << setw(24) << "办理中..." << endl;
cout << endl;
}
system("pause");
break;
case 3:
char s3;
int x;
cout << "是否完成该客户业务（是:y/Y,否：n/N）:";
cin >> s3;
if (s3 == 'y' || s3 == 'Y')
{
try
{
Q.DeQueue();
g--;
}
catch (char*wrong)
{
cout << wrong << endl;
}
}
else {
cout << "还有客户正在办理业务" << endl;
}
cout << "当前正在受理的是:" << endl;
cout << Q.GetQueue() << "号客户" << endl;
system("pause");
break;
case 4:
cout << "当前正在受理的是:" << endl;
cout << Q.GetQueue() << "号客户" << endl;
system("pause");
break;
case 5:
show();
system("pause");
break;
}
} while (select != 6);
cout << left;
}
void show()
{
cout << "姓名" << setw(10) << "联系电话" << endl;
for (int i = 1; i <= n; i++)
{
cout << data[i].name << setw(10) << data[i].tel << endl;
}
cout << endl;
}



 

 

 
 


 
 
 


   

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

                            

                    

                

                

                    

                        

                            
相关推荐

                            



                                
【啊哈！算法】算法3：最常用的排序——快速排序

                                
【啊哈！算法】算法3：最常用的排序——快速排序       上一节的冒泡排序可以说是我们学习第一个真正的排序算法，并且解决了桶排序浪费空间的问题，但在算法的执行效率上却牺牲了很多，它的时间复杂度达到了O(N2)。假如我们的计算机每秒钟可以运行10亿次，那么对1亿个数进行排序，桶排序则只需要0.1秒，而冒泡排序则需要1千万秒，达到115天之久，是不是很吓人。那有没有既不浪费空间又可以快一点的排序算法

                            

                                
[数据结构与算法]模式匹配与文本处理-匿名组与命名组

                                
匿名组 这里可能用到几个不同的分组构造。通过括号内围绕的正则表达式就可以组成第一个构造。正如稍后要介绍的一样，既然也可以命名组，大家就有考虑把这个构造作为匿名组。作为一个实例，请看看下列字符串： “08/14/57 46 02/25/59 45 06/05/85 18  03/12/88 16 09/09/90 13“ 这个字符串就是由生日和年龄组成的。如果需要匹配年两而不要生日，就可以把正则

                            

                                
[C#]选择排序

                                
选择排序：从数组的起始位置处开始，把第一个元素与数组中其他元素进行比较。然后，将最小的元素方式在第0个位置上，接着再从第1个位置开始再次进行排序操作。这种操作一直到除最后一个元素外的每一个元素都作为新循环的起始点操作过后才终止。         public void SelectionSort()          {             int min, temp;

                            

                                
[数据结构与算法]队列的优先级

                                
public struct Pqitem    {        public int priority;        public string name;    }    class CQueue    {        private ArrayList pqueue;         public CQueue()         {            pqueue

                            

                                
[数据结构与算法]模式匹配-数量词

                                
在编写正则表达式的时候，经常会向要向正则表达式添加数量型数据，诸如”精确匹配两次”或者”匹配一次或多次”。利用数量词就可以把这些数据添加到正则表达式里面了。     数量词(+):这个数量词说明正则表达式应该匹配一个或多个紧紧接其前的字符。       string[] words = new string[] { "bad", "boy", "baad", "baaad" ,"bear", "b

                            

                                
[数据结构与算法]白话经典算法系列之五 归并排序的实现

                                
来自：http://blog.csdn.net/morewindows/article/details/6678165/归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列

                            

                                
[C#]插入排序

                                
插入排序算法有两层循环。外层循环会啄个遍历数组元素，而内存循环则会把外层循环所选择的元素与该元素在数组内的下一个元素进行比较。如果外层循环选择的元素小于内存循环选择的元素，那么瘦元素都想右移动以便为内存循环元素留出位置。         public void InsertionSort()          {             int inner, temp;

                            

                                
[C#]二叉查找法

                                
public  int binSearch(int value)         {             int upperBround, lowerBound, mid;             upperBround = arr.Length - 1;             lowerBound = 0;             while (lowerBound <= upper

                            

                                
[数据结构与算法]双向链表

                                
虽然从表内第一个节点到最后一个节点的遍历操作是非常简单的，但是反向遍历链表却不是一件容易的事情。如果为Node类添加一个字段来存储指向前一个节点的连接，那么久会使得这个反向操作过程变得容易许多。当向链表插入节点的时候，为了吧数据复制给新的字段会需要执行更多的操作，但是当腰吧节点从表移除的时候就能看到他的改进效果了。     首先需要修改Node类来为累增加一个额外的链接。为了区别两个连接，这个把指

                            

                                
[数据结构]树及树的遍历

                                
八、树（Tree）树，顾名思义，长得像一棵树，不过通常我们画成一棵倒过来的树，根在上，叶在下。不说那么多了，图一看就懂：当然了，引入了树之后，就不得不引入树的一些概念，这些概念我照样尽量用图，谁会记那么多文字？树这种结构还可以表示成下面这种方式，可见树用来描述包含关系是很不错的，但这种包含关系不得出现交叉重叠区域，否则就不能用树描述了，看图：面试的时候我们经常被考到的是一种叫“二叉树”的结构，二叉

                            

                                
[数据结构]队列的操作

                                
Queue的实现：     就像Stack类的实现所做的一样，Queue类的实现用ArrayList简直是毋庸置疑的。对于这些数据结构类型而言，由于他们都是动态内置的结构，所以ArrayList是极好的实现选择。当需要往队列中插入数据项时，ArrayList会在表中把每一个保留的数据项向前移动一个元素。    class CQueue    {        private ArrayLis

                            

                                
[数据结构与算法]常用排序算法的动画效果图

                                
来自：http://yingyingol.iteye.com/blog/13348911 快速排序介绍：快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地

                            

                                
[C#]Stack类的实现

                                
Stack的实现必须采用一种基本结构来保存数据。因为再新数据项进栈的时候不需要担心调整表的大小，所以选择用arrayList.using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Collecti

                            

                                
[C#]冒泡排序

                                
数组类测试环境与排序算法using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace Data_structure_and_algorithm{    class CArray    {        pr

                            

                                
[数据结构与算法]二叉树与二叉树遍历

                                
一、构造二叉树       二叉树查找树由节点组成，所以需要有个Node类，这个类类似于链表实现中用到的Node类。首先一起来看看Node类的代码。    public class Node    {        public int Data;            public Node Left;        public Node Right;        public v

                            

                                
【啊哈！算法】算法10：二叉树

                                
二叉树是一种特殊的树。二叉树的特点是每个结点最多有两个儿子，左边的叫做左儿子，右边的叫做右儿子，或者说每个结点最多有两棵子树。更加严格的递归定义是：二叉树要么为空，要么由根结点、左子树和右子树组成，而左子树和右子树分别是一棵二叉树。 下面这棵树就是一棵二叉树。         二叉树的使用范围最广，一棵多叉树也可以转化为二叉树，因此我们将着重讲解二叉树。二叉树中还有连两种特殊的二叉树叫做满二叉树和

                            

                                
【啊哈！算法】算法4：解密QQ号——队列

                                
上一节中我们学习了队列，它是一种先进先出的数据结构。还有一种是后进先出的数据结构它叫做栈。栈限定只能在一端进行插入和删除操作。比如说有一个小桶，小桶的直径只能放一个小球，我们现在向小桶内依次放入2号、1号、3号小球。假如你现在需要拿出2号小球，那就必须先将3号小球拿出，再拿出1号小球，最后才能将2号小球拿出来。在刚才取小球的过程中，我们最先放进去的小球最后才能拿出来，而最后放进去的小球却可以最先拿

                            

                                
[数据结构与算法]模式匹配与文本处理-零宽度正预测先行断言 and 零宽度正回顾后发断言

                                
msdn中的描述如下：(?= 子表达式)（零宽度正预测先行断言。） 仅当子表达式在此位置的右侧匹配时才继续匹配。例如，w+(?=d) 与后跟数字的单词匹配，而不与该数字匹配。此构造不会回溯。(?（零宽度正回顾后发断言。） 仅当子表达式在此位置的左侧匹配时才继续匹配。例如，(?此构造不会回溯。msdn描述的比较清楚，如：w+(?=ing) 可以匹配以ing结尾的单词(匹配结果不包括ing)，(

                            

                                
[数据结构]线索二叉树

                                
1.引入线索二叉树    二叉树的遍历实质上是对一个非线性结构实现线性化的过程，使每一个节点(除第一个和最后一个外)在这些线性序列中有且仅有一个直接前驱和直接后继。但在二叉链表存储结构中，只能找到一个节点的左、右孩子信息，而不能直接得到节点在任一遍历序列中的前驱和后继信息。这些信息只有在遍历的动态过程中才能得到，因此，引入线索二叉树来保存这些从动态过程中得到的信息。 2.建立线索二叉树 为了保

                            

                                
[数据结构与算法]超级详细解读基本排序算法不看后悔，带排序演示动画

                                
排序与我们日常生活中息息相关，比如，我们要从电话簿中找到某个联系人首先会按照姓氏排序、买火车票会按照出发时间或者时长排序、买东西会按照销量或者好评度排序、查找文件会按照修改时间排序等等。在计算机程序设计中，排序和查找也是最基本的算法，很多其他的算法都是以排序算法为基础，在一般的数据处理或分析中，通常第一步就是进行排序，比如说二分查找，首先要对数据进行排序。在Donald Knuth 的计算机程序设

                            

                    



            

            

              
          

            

              




              

            

          

          
          

            

              

                  
    
              

            

          

          

            

              

                  
    
              

            

          

          
          

            

              

                
                
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot