c练习题——两个队列同时进行服务

1. main.c

#include <stdio.h>
#include <stdlib.h>
#include "queue.h"

#define MINPERHOUR 60.0
#define SERVERTIMEMAX 3

bool customertime(double i_num);
Item news_customer(int then);

int main(void) {
	Queue line1, line2;
	Item customer;
	int i_QueueSize1, i_QueueSize2, i_QueueTime1, i_QueueTime2, i_TimeCount, i_TimeLimit, i_ServiceTime1, i_ServiceTime2, i_hours, i_TatalCustomers, i_ServicedCustomers1, i_ServicedCustomers2, i_LeavedCustomers, i_PersonPerHour;
	i_QueueSize1 = i_QueueSize2 = i_QueueTime1 = i_QueueTime2 = i_TimeCount = i_ServiceTime1 = i_ServiceTime2 = i_TatalCustomers = i_ServicedCustomers1 = i_ServicedCustomers2 = i_LeavedCustomers = 0;
	double lf_min;
	puts("Please Enter a number of hours: ");
	scanf_s("%d", &i_hours);
	i_TimeLimit = i_hours * (int)MINPERHOUR;
	puts("Please Enter a number of PersonPerHour: ");
	scanf_s("%d", &i_PersonPerHour);
	lf_min = MINPERHOUR / i_PersonPerHour;
	InitializeQueue(&line1);
	InitializeQueue(&line2);

	for (i_TimeCount; i_TimeCount < i_TimeLimit; i_TimeCount++)
	{
		if (customertime(lf_min)){		// 为真时加入新顾客
			if (!QueueIsFull(&line1) && QueueItemCount(&line1) <= QueueItemCount(&line2)) {
				i_TatalCustomers++;
				customer = news_customer(i_TimeCount);
				AddQueue(customer, &line1);
			}
			else if(!QueueIsFull(&line2) && QueueItemCount(&line1) > QueueItemCount(&line2)){
				i_TatalCustomers++;
				customer = news_customer(i_TimeCount);
				AddQueue(customer, &line2);
			}
			else{
				i_LeavedCustomers++;
			}
		}
		if (i_ServiceTime1<=0 && (!QueueIsEmpty(&line1))) {
			DelQueue(&customer, &line1);
			i_ServiceTime1 = customer.service_time;
			i_QueueTime1 += i_TimeCount - customer.join_time;
			i_ServicedCustomers1++;
		}
		if (i_ServiceTime2 <= 0 && (!QueueIsEmpty(&line2))) {
			DelQueue(&customer, &line2);
			i_ServiceTime2 = customer.service_time;
			i_QueueTime2 += i_TimeCount - customer.join_time;
			i_ServicedCustomers2++;
		}
		if (i_ServiceTime1 >0 ){
			i_ServiceTime1--;
		}
		if (i_ServiceTime2 > 0) {
			i_ServiceTime2--;
		}
		i_QueueSize1 += QueueItemCount(&line1);
		i_QueueSize2 += QueueItemCount(&line2);
	}
	if (i_TatalCustomers > 0){
		printf("顾客数量：%d\n", i_TatalCustomers);
		printf("服务顾客数量：\n摊铺1：%d \t 摊铺2：%d\n", i_ServicedCustomers1, i_ServicedCustomers2);
		printf("顾客离开数量：%d\n", i_LeavedCustomers);
		printf("队列长度：\n摊铺1：%.2f \t 摊铺2：%.2f\n", (double)(i_QueueSize1/ i_TimeLimit), (double)(i_QueueSize2/ i_TimeLimit));
		if (i_ServicedCustomers1 > 0){
			printf("队列平均等候时间：\n摊铺1：%.2f \t", (double)(i_QueueTime1 / i_ServicedCustomers1));
		}
		if (i_ServicedCustomers2 > 0){
			printf("摊铺2：%.2f\n", (double)(i_QueueTime2 / i_ServicedCustomers2));
		}
		else{
			printf("摊铺2：NULL\n");
		}
	}
	else{
		printf("All customers are %d of the mall\n", i_TatalCustomers);
	}
	EmptyTheQueue(&line1);
	EmptyTheQueue(&line2);
	return 0;
}

bool customertime(double i_num) {
	return rand()* i_num / RAND_MAX < 1 ? true : false;  // i_num次里出现一次的结果 < 1 (rand() / RAND_MAX < 1 / num)
}

Item news_customer(int then) {
	Item cust;
	cust.join_time = then;
	cust.service_time = rand() % SERVERTIMEMAX + 1;
	return cust;
}

2. queue.h

#pragma once
#ifndef QUEUE_H_
#define	QUEUE_H_
#include <stdbool.h>
typedef struct item{
	int join_time;
	int service_time;
}Item;

typedef struct node{
	Item item;
	struct node* next;
}Node;

typedef struct queque {
	Node* head;
	Node* end;
	int items;
}Queue;

// 初始化队列
void InitializeQueue(Queue* p_queue);

// 判断队列是否已满
// p_queue指向一个已初始化的队列
bool QueueIsFull(const Queue* p_queue);

// 判断队列是否为空
// p_queue指向一个已初始化的队列
bool QueueIsEmpty(const Queue* p_queue);

// 确认队列中的项数
// p_queue指向一个已初始化的队列
int QueueItemCount(const Queue* p_queue);

// 判断添加新的队列是否成功
// item 为加入的新成员，p_queue指向一个已初始化的队列
bool AddQueue(Item item, Queue* p_queue);

// 判断删除队列是否成功
// p_item指向一个被删除成员的备用地址，p_queue指向一个已初始化的队列
bool DelQueue(Item* p_item, Queue* p_queue);

// 释放队列分配的内存空间
// p_queue指向一个已初始化的队列
void EmptyTheQueue(Queue* p_queue);

#endif // !QUEUE_H_

3. queue.c

#include <stdio.h>
#include <stdlib.h>
#include "queue.h"

#define QUEUEMAX 10
static void CopyToNode(Item item, Node* p_node);
static void CopyToItem(Node* p_node, Item* p_item);

// 初始化队列
void InitializeQueue(Queue* p_queue) {
	p_queue->end = NULL;
	p_queue->head = NULL;
	p_queue->items = 0;
}

// 判断队列是否已满
// p_queue指向一个已初始化的队列
bool QueueIsFull(const Queue* p_queue) {
	return p_queue->items == QUEUEMAX ? true : false;
}

// 判断队列是否为空
// p_queue指向一个已初始化的队列
bool QueueIsEmpty(const Queue* p_queue) {
	return p_queue->items == 0 ? true : false;
}

// 确认队列中的项数
// p_queue指向一个已初始化的队列
int QueueItemCount(const Queue* p_queue) {
	return p_queue->items;
}

// 判断添加新的队列是否成功
// item 为加入的新成员，p_queue指向一个已初始化的队列
bool AddQueue(Item item, Queue* p_queue) {
	Node* p_node;
	p_node = (Node*)malloc(sizeof(Node));
	if (p_node){
		CopyToNode(item, p_node);
		p_node->next = NULL;
		if (QueueIsEmpty(p_queue)){
			p_queue->head = p_node;		// 将首地址改成该节点
		}
		else {
			p_queue->end->next = p_node;
		}
		p_queue->end = p_node;
		p_queue->items += 1;
		return true;
	}
	else {
		puts("获取内存失败");
		return false;
	}
}

// 判断删除队列是否成功
// p_item指向一个被删除成员的备用地址，p_queue指向一个已初始化的队列
bool DelQueue(Item* p_item, Queue* p_queue) {
	Node* p_node;
	CopyToItem(p_queue->head, p_item);
	p_node = p_queue->head;
	if (p_node){
		p_queue->head = p_queue->head->next;
		free(p_node);
		p_queue->items -= 1;
		if (p_queue->items == 0){
			p_queue->end = NULL;
		}
		return true;
	}
	else{
		return false;
	}
}

// 释放队列分配的内存空间
// p_queue为一个已初始化的队列
void EmptyTheQueue(Queue* p_queue) {
	Item* p_item = NULL;
	while (!QueueIsEmpty(p_queue)){
		DelQueue(p_item, p_queue);
	}
}

// 添加新成员到节点
static void CopyToNode(Item item, Node * p_node) {
	if (p_node){
		p_node->item = item;
	}
}

// 将节点中删除的成员移到新地址备用
static void CopyToItem(Node* p_node, Item * p_item) {
	if (p_node && p_item){
		*p_item = p_node->item;
	}
}