银行业务模拟 数据结构课程设计

[niuniu317]

假设某银行有4个窗口对外接待客户，从早晨银行开门起不断有客户进入银行，由于每个窗口在某个时刻只能接待一个客户。因此在客户人数众多时需要在每个窗口前顺次排队，对于刚进和银行的客户。如果某个窗口的业务员正空闲，则可上前输业务。反之，若个窗口均有客户所占，他便会排在为数最少的队伍后面。编制一个程序模拟银行的这种业务活动并计算一天中客户在银行的平均逗留时间。
哪位高手指点一下银行业务模拟程序中涉及到的算法思想 谢谢！！！

[t1397018]

~用一个数组存放每个窗口上的人数
每个客户进来到人最少的地方就行了
～～

[na2650945]

友情up。
等待大牛。

[lean_NB]

呵呵 前几天研究了一阵子的算法。
其实主要是用链表记录事件，队列记录4个排队

[wxc0077]

四个队列
class CQueue
{
pubilc:
pop();//表示处理完业务，脱离队伍
push();//排入队伍中，等待
getCount（int& count);//得到队列现有数量
private：
int m_Count; //队列现有数量
}
你只要去判断m_Count，然后调用push（）方法就好了

[dbianbian]

貌似这是严蔚敏那本数据结构的一道例题

[li_il]

我觉得你说的够清楚了，你都把整个过程描述出来了，你肯定就知道该如何编程了吧？

我说一下我的想法：

1.一个银行有3个窗口。

2.一个客户去银行办理金融业务。

银行是一个类，窗口是一个类，客户也是一个类。

客户进入银行。。。。（我具体一点说）银行.in客户（客户）。

客户选择哪个窗口是一个问题，你要明白客户是不太想自己数现在哪个窗口有多少人排队，如果银行知道那个窗口有多少人排队，或者更精确一点，哪个窗口知道自己
这个窗口前面有多少人，那是不是就可以找个LCD屏幕，显示一下现在有多少人排队？这样客户就很方便的知道该排哪个队了？

一个客户办完当前业务，就离开银行，银行.out客户（）。

银行知道客户进来了，那么就知道一天进来了多少人，客户出去了，那银行肯定知道现在整个银行剩下多少人。
剩下超过0人，计时，没人，不记时。

最后，你想知道平均逗留时间，银行.平均逗留时间()，就行了。

很简单吧？

[li_il]

class CBank
{
public:
CBank(void);
~CBank(void);
public:
void inBank(CClient*);
void outBank(void);
size_t aveStayTime(void) const;


private:
std::queue<CClient*> m_bankWnds[3]; //三个窗口
size_t m_nClient; // 当前银行人数
size_t m_nStayTimeTotal; // 逗留的总时间
size_t m_nClientTotal; // 全天总人数
};
每次调用inBank的时候，加合适时间。
每一次调用outBank的时候，如果客户出去以后银行还有人，那么总时间加上合适的时间。

仓促写的，可能有很多没考虑。

[niuniu317]

谢谢各位指点

[li_il]

// BankWnd.h
#pragma once
#include <queue>
#include "Client.h"

class CBankWnd
{
public:
	CBankWnd(void);
	~CBankWnd(void);
public:
	void push(const CClient&);
	void pop(void);
	void clear(void);
	size_t size(void) const;
	bool empty(void) const;


private:
	std::queue<CClient> m_queueClients; 
};

// BankWnd.cpp
#include "BankWnd.h"

CBankWnd::CBankWnd(void)
{
}

CBankWnd::~CBankWnd(void)
{
}

void CBankWnd::push( const CClient& client)
{
	m_queueClients.push(client);
}

void CBankWnd::pop( void )
{
	m_queueClients.pop();
}

bool CBankWnd::empty( void ) const
{
	return m_queueClients.empty();
}

size_t CBankWnd::size( void ) const
{
	return m_queueClients.size();
}

void CBankWnd::clear( void )
{
	while(!m_queueClients.empty()){
		m_queueClients.pop();
	}
}

// Bank.h
#pragma once
#include <ctime>
#include "BankWnd.h"
#include "Client.h"

class CBank
{
public:
	CBank(void);
	~CBank(void);
public:
	void onWork(void);
	void offWork(void);
	void inBank(const CClient& client);
	void outBank(void);
	size_t clientTotal(void) const;
	size_t stayTimeTotal(void) const;
	size_t aveStayTime(void) const;


private:
	static const int UNIT_TIME = 20;
	static const int NUM_WND = 3;
private:
	CBankWnd m_bankWnds[NUM_WND]; 
	size_t m_nClient; // current client number	
	size_t m_nStayTimeTotal;	
	size_t m_nClientTotal;
};

// Bank.cpp
#include "Bank.h"

CBank::CBank(void)
:m_nClient(0), m_nClientTotal(0), m_nStayTimeTotal(0)
{
	srand((unsigned)time(NULL));
}

CBank::~CBank(void)
{
}

void CBank::inBank(const CClient& client)
{
	size_t minLengthWnd(0);
	for (size_t idx(0); idx != NUM_WND; ++idx){
		if(m_bankWnds[idx].size() < m_bankWnds[minLengthWnd].size()){
			minLengthWnd = idx;
		}
	}
	m_bankWnds[minLengthWnd].push(client);

	m_nStayTimeTotal += UNIT_TIME;
	m_nClientTotal += 1;
	m_nClient += 1;
}

void CBank::outBank( void )
{
	switch(rand() % NUM_WND){
		case 1:
			if (!m_bankWnds[0].empty()){
				m_bankWnds[0].pop();
				m_nClient -= 1;
			}
			break;
		case 2:
			if (!m_bankWnds[1].empty()){
				m_bankWnds[1].pop();
				m_nClient -= 1;
			}
			break;
		case 3:
			if (!m_bankWnds[2].empty()){
				m_bankWnds[2].pop();
				m_nClient -= 1;
			}
			break;
	}

	m_nStayTimeTotal += m_nClient * UNIT_TIME;
}

size_t CBank::aveStayTime( void ) const
{
	if (m_nClientTotal == 0){
		return 0;
	}
	else{
		return m_nStayTimeTotal / m_nClientTotal;
	}
}

void CBank::onWork( void )
{
	m_nClient = 0;
	m_nClientTotal = 0;
	m_nStayTimeTotal = 0;
}

void CBank::offWork( void )
{
	for (size_t idx(0); idx != NUM_WND; ++idx){
		m_bankWnds[idx].clear();
	}
	m_nClient = 0;
}

size_t CBank::clientTotal( void ) const
{
	return m_nClientTotal;
}

size_t CBank::stayTimeTotal( void ) const
{
	return m_nStayTimeTotal;
}

// client.h

#pragma once

class CClient
{
public:
	CClient(void);
	~CClient(void);
};

bool operator<(const CClient& lClient,const CClient& rClient);
bool operator==(const CClient& lClient,const CClient& rClient);
bool operator!=(const CClient& lClient,const CClient& rClient);

// client.cpp
#include "Client.h"

CClient::CClient(void)
{
}

CClient::~CClient(void)
{
}


bool operator<(const CClient& lClient,const CClient& rClient)
{
	return false;
}

bool operator==( const CClient& lClient,const CClient& rClient )
{
	return false;
}

bool operator!=( const CClient& lClient,const CClient& rClient )
{
	return true;
}

#include "Bank.h"
#include "Client.h"
#include <iostream>


int _tmain(int argc, _TCHAR* argv[])
{
	CBank myBank;
	CClient client;

	myBank.onWork();

	for (size_t i(0); i != 10; ++i){
		for (size_t j(0); j != 5; ++j){
			if (rand() % 100 > 50){
				myBank.inBank(client);
			}
		}
		for (size_t j(0); j != 5; ++j){
			myBank.outBank();
		}
	}

	myBank.offWork();

	std::cout <<myBank.clientTotal() << '\n';
	std::cout << myBank.stayTimeTotal() << '\n';
	std::cout << myBank.aveStayTime() << '\n';

	return 0;
}

有些地方写的不好。

[shipeng_sunny]

你学过STL吧，向大牛学习！

[wsew2009]

学习..