LinuxC练习：停车场项目：停车场是一个能放 n 辆车的狭长通道，只有一个大门，汽车按到达的先后次序停放。若车场满了，车要停在门 外的便道上等候，一旦有车走，则便道上第一辆车进入。当停车场中

最新推荐文章于 2022-12-05 17:33:31 发布
最新推荐文章于 2022-12-05 17:33:31 发布
阅读量7.7k 收藏 10
点赞数 8
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29993901/article/details/79675553
版权
基本功能要求：
          （1）建立三个数据结构分别是：停放栈、让路栈、等候队列。
          （2）输入数据模拟管理过程，数据（入或出，车号）


功能描述：进车登记、出车登记、按车牌号查询停车车辆信息、查询出入车记录、
          查询场内车辆信息、查询等候车辆信息、退出系统。
          （1）linux系统编写（链表、栈、队列）；
          （2）进车登记：登记车牌号以及入场时间；
          （3）出车登记：计算出停车时间，记录车辆车牌；
  （4）按车牌号查询车辆信息：停车时间，是否来过停车场，是否还在停车场
          （5）查询出入记录：所有车辆，包括已经离开的
          （6）查询场内车辆信息：列出所有场内车辆信息
  （7）查询等候车辆信息：显示等候车辆数量以及所有车牌号

  （8）退出系统。

Car.h

#ifndef _CAR_H_
#define _CAR_H_

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
enum
{
	SUCCESS = 10000,
	FAILURE,
	TRUE,
	FALSE,
};

struct carinfo
{
	char *carnum;

	char *entertime;
	char *outtime;

	long int enterseconds;
	long int outseconds;

	int enterflag;
	int outflag; 
	int waitflag;

	int fee;

	struct carinfo *next;

};

typedef struct carinfo CarInfo;

struct carstack
{
	CarInfo *top;
	int length;
};
typedef struct carstack CarStack;

struct carqueue
{
	CarInfo *front;
	CarInfo *rear;
};
typedef struct carqueue CarQueue;

int Welcome();
int Login();
int CarMenue();
int CheckCarnumStack(CarStack *cs1, char *carnum);
int CheckCarnumQueue(CarQueue *cq, char *carnum);
int ShowByCarnum(CarStack *s, CarStack *s1, CarQueue *q, void(p)(CarInfo *));
int InitCarStack(CarStack **s);
int Push(CarStack *s, CarInfo *c);
CarInfo *Pop(CarStack *s);
int EnterCarPark(CarStack *s, CarQueue *q);
int LeaveCarPark(CarStack *s, CarStack *s1,CarStack *s2, CarQueue *q);
int TraverseCarStack(CarStack *s, void (*p)(CarInfo *));
int EmptyCarStack(CarStack *s);
int InitCarQueue(CarQueue **q);
int EnterCarQueue(CarQueue *q, CarStack *s);
int EmptyCarQueue(CarQueue *q);
int LengthCarQueue(CarQueue *q);
CarInfo *DeleteCarQueue(CarQueue *q);
int TraverseCarQueue(CarQueue *q, void (*p)(CarInfo *));

#endif

Car.c
#include "Car.h"

int Welcome()
{
	system("clear");
	printf("\t\t\t************************************************************\n");
	printf("\t\t\t------------------------------------------------------------\n");
	printf("\t\t\t****************Welcome To  CarPark  System*****************\n");
	printf("\t\t\t------------------------------------------------------------\n");
	printf("\t\t\t*******************Made By Autumn Sun***********************\n");
	printf("\t\t\t------------------------------------------------------------\n");
	printf("\t\t\t************************************************************\n");
	sleep(2);
	return 0;
}

int Login()
{
	system("clear");
	char *LoginName = (char *)malloc(sizeof(char) * 20);
	char *LoginPassword = (char *)malloc(sizeof(char) * 20);
	if(NULL == LoginName || NULL == LoginPassword)
	{
		printf("NULL ERROR\n");
		exit(1);
	}
	int ret;
	printf("请输入登录名\n");
	scanf("%s", LoginName);
	printf("请输入登录密码\n");
	scanf("%s", LoginPassword);
	ret = strcmp(LoginName, LoginPassword);
	if(ret != 0)
	{
		return FAILURE;
	}
	else
	{
		return SUCCESS;
	}

}



int CarMenue()
{
	printf("\t\t\t1、显示车库             2、显示等候\n");
	printf("\t\t\t3、进入车库             4、离开车库\n");
	printf("\t\t\t5、查询所有             6、推出系统\n");
	return 0;
}

int CheckCarnumStack(CarStack *cs1, char *carnum)
{
	int flag = 0;
	if(NULL == cs1)
	{
		return FAILURE;
	}

	CarInfo *q = cs1 -> top;
	while(q)
	{
		if(0 == strcmp(q -> carnum, carnum))
		{
			flag = 1;
		}
		q = q ->next;
	}
	

	if(flag == 0)
	{
		return FALSE;
	}
	else
	{
		return TRUE;
	}


}

int CheckCarnumQueue(CarQueue *cq, char *carnum)
{
	if(NULL == cq)
 	{
     	return FAILURE;
 	}
	int flag = 0;
	CarInfo *q1 = cq -> front -> next;
	while(q1)
	{
		if(0 == strcmp(q1 -> carnum, carnum))
		{
			flag = 1;
		}
		q1 = q1 -> next;
	}
	if(flag == 0)
	{
		return FALSE;
	}
	else
	{
		return TRUE;
	}


}



int ShowByCarnum(CarStack *s, CarStack *s1, CarQueue *q, void(p)(CarInfo *))
{
	CarInfo *tmp1 = s -> top;
	CarInfo *tmp2 = s1 -> top;
	CarInfo *tmp3 = q -> front -> next;
	char *carnum = (char *)malloc(sizeof(char) * 20);
	if(NULL == carnum)
	{
		printf("NULL ERROR\n");
		return FAILURE;
	}
	printf("请输入要离开的车牌号\n");
	scanf("%s", carnum);
	while(tmp1)
	{
		if(strcmp(tmp1 -> carnum, carnum) == 0)
		{
			printf(" 状态：在停车场\n");
			p(tmp1);

		}
		tmp1 = tmp1 -> next;
	}

	while(tmp2)
	{
		if(strcmp(tmp2 -> carnum, carnum) == 0)
		{
			printf("状态：已经离开\n");
			p(tmp2);
		}
		tmp2 = tmp2 -> next;
	}

	while(tmp3)
	{
		if(strcmp(tmp3 -> carnum, carnum) == 0)
		{
			printf("状态：正在等候\n");
			p(tmp3);
		}
		tmp3 = tmp3 -> next;
	}
	return SUCCESS;
}

CarQueue.c
#include "Car.h"

int InitCarQueue(CarQueue **q)//初始化等候区
{
	if (NULL == q)
	{
		return FAILURE;
	}

	(*q) = (CarQueue *)malloc(sizeof(CarQueue));
	if ((*q) == NULL)
	{
		return FAILURE;
	}

	CarInfo *n = (CarInfo *)malloc(sizeof(CarInfo));
	if (NULL == n)
	{
		return FAILURE;
	}

	n->next = NULL;

	(*q)->rear = (*q)->front = n;

	return SUCCESS;
		
}

int EnterCarQueue(CarQueue *q, CarStack *s)// 将车辆进入等候区
{
	if (NULL == q)
	{
		return FAILURE;
	}
	
	int ret, ret1;
	CarInfo *n = (CarInfo *)malloc(sizeof(CarInfo));
	n -> carnum = (char *)malloc(sizeof(char) * 10);
	n -> entertime = (char *)malloc(sizeof(char) * 20);
	n -> outtime = (char *)malloc(sizeof(char) * 20);
	n -> waitflag = 1;
	char *carnum = (char *)malloc(sizeof(char) * 10);
	if (NULL == n || NULL == n -> carnum || NULL == n -> entertime || NULL == n -> outtime || NULL == carnum)
	{
		return FAILURE;
	}

	printf("请输入车牌号\n");
	scanf("%s", carnum);
	ret = CheckCarnumStack(s, carnum);
	ret1 = CheckCarnumQueue(q, carnum);
	while(TRUE == ret || TRUE == ret1)
	{
		printf("请重新输入车牌号\n");
		memset(carnum, 0, 10);
		scanf("%s", carnum);
		ret = CheckCarnumStack(s, carnum);
		ret1 = CheckCarnumQueue(q, carnum);

	}
	strcpy(n ->carnum, carnum);
	strcpy(n -> entertime, " ");
	strcpy(n -> outtime, " ");
	n -> fee = 0;
	n -> enterflag = 0;
	n -> outflag = 0;
	n->next = NULL;
	q->rear->next = n;
	q->rear = n;

	return SUCCESS;
}

int EmptyCarQueue(CarQueue *q)//判断等候区是否有车
{
	if (NULL == q)
	{
		return FAILURE;
	}

	return (q->rear == q->front) ? TRUE : FALSE; 
}

int LengthCarQueue(CarQueue *q)//求得等候区车辆数
{
	if (NULL == q)
	{
		return FAILURE;
	}

	CarInfo *p = q->front;
	int length = 0;

	while (p != q->rear)
	{
		p = p->next;
		length++;
	}

	return length;
}
//将车从等候区出去，返回车辆信息
CarInfo *DeleteCarQueue(CarQueue *q)
{
	if (NULL == q || q->rear == q->front)
	{	
		return NULL;
	}

	CarInfo *p = q->front->next;
	q->front->next = p->next;
		
	if (p == q->rear)
	{
		q->rear = q->front;
	}
	
	return p;
}

int TraverseCarQueue(CarQueue *q, void (*p)(CarInfo *))//现实等候区所有车辆
{
	if (NULL == q || p == NULL)
	{
		return FAILURE;
	}
	
	int length = LengthCarQueue(q);
	printf("目前有%d在等候区\n", length);
	
	CarInfo *n = q->front->next;
	while (n)
	{
		p(n);
		n = n->next;
	}
	
	return SUCCESS;
}


CarStack.c
#include "Car.h"

int InitCarStack(CarStack **s)//初始化车库
{
	*s = (CarStack *)malloc(sizeof(CarStack));
	if (NULL == (*s))
	{
		return FAILURE;
	}

	(*s)->top = NULL;
	(*s)->length = 0;	

	return SUCCESS;
}

int Push(CarStack *s, CarInfo *c)
{
	if(NULL == s)
	{
		return FAILURE;
	}

	c -> next = s -> top;
	s -> top = c;
	s -> length ++;
	return SUCCESS;
}

CarInfo *Pop(CarStack *s)
{
	if(NULL == s || NULL == s -> top)
	{
		return NULL;
	}
	
	CarInfo *c = s -> top;
	s -> top = c -> next;
	s -> length --;
	
	//tmp = c;
	//tmp -> next = NULL; 
	return c;
}


int EnterCarPark(CarStack *s, CarQueue *q)//将车牌号添加进车库
{
	if (NULL == s || NULL == q)
	{
		return FAILURE;
	}

	CarInfo *p = (CarInfo *)malloc(sizeof(CarInfo));
	p -> carnum = (char *)malloc(sizeof(char) * 10);
	p -> entertime = (char *)malloc(sizeof(char) * 20);
	p -> outtime = (char *)malloc(sizeof(char) * 20);
	char *carnum = (char *)malloc(sizeof(char) * 10);
	if (NULL == p|| NULL == p -> carnum || NULL == p -> entertime || NULL == p -> outtime || NULL == carnum)
	{
		return FAILURE;
	}
	int ret, ret1;
	//获取时间
	time_t timep;

	if(s -> length > 5)//如果车库满了则将车转到等候区
	{
		printf("停车场已经满了，请进入等候区\n");
		ret = EnterCarQueue(q, s);
		if(SUCCESS == ret)
		{
			printf("进入等候区成功\n");
		}
		else
		{
			printf("进入等候区失败\n");
		}
	}
	else if(s -> length <= 5 && EmptyCarQueue(q) == TRUE)//如果等候区没有车且车库没有满
	{
		printf("请输入车牌号\n");
		scanf("%s", carnum);
		
		ret = CheckCarnumStack(s, carnum);
		ret1 = CheckCarnumQueue(q, carnum);
		while(TRUE == ret || TRUE == ret1)
		{
			system("clear");
			printf("请重新输入车牌号\n");
			memset(carnum, 0, 10);
			scanf("%s", carnum);
			ret = CheckCarnumStack(s, carnum);
			ret1 = CheckCarnumQueue(q, carnum);

		}
		strcpy(p -> carnum, carnum);
		p -> outseconds = 0;
		strcpy(p -> outtime, " ");
		p -> fee = 0;
		p -> enterseconds = time(&timep);//获取描述
		strcpy(p -> entertime, ctime(&timep));
		p -> enterflag = 1;
		p -> outflag = 0;
		p -> waitflag  =1;
		printf("入场时间:%s\n", p -> entertime);
		Push(s, p);		
	}
	return SUCCESS;
}

						                     			 //出车时如果等候区有车则将等候区的第一辆车进入到车库中、length不变
  						                       //如果等候区没有车，则length --；
int LeaveCarPark(CarStack *s, CarStack *s1,CarStack *s2, CarQueue *q)//s为停车场，s1为方便停车的区域， s2为记录离开的车子
{
	char *carnum = (char *)malloc(sizeof(char) * 10);
	CarInfo *tmp ;
	CarInfo *tmp1;
	CarInfo *tmp2;
	CarInfo *tmp3;
	CarInfo *tmp4;
	int ret, ret2;

	if (NULL == s || NULL == s->top || NULL == carnum)
	{
		return FAILURE;
	}
	printf("请输入要离开的车牌号\n");
	scanf("%s", carnum);
	ret = CheckCarnumStack(s, carnum);
	while(FALSE == ret)
	{
		printf("请重新输入\n");
		memset(carnum, 0, 10);
		scanf("%s", carnum);
		ret = CheckCarnumStack(s, carnum);
		 
	}
	tmp = s -> top;
	while(tmp)
	{
		 
		 if(strcmp(tmp -> carnum, carnum) == 0)
		 {
		 	tmp1 = tmp;
			break;
		 }
		 tmp4 = Pop(s);
		 if(NULL == tmp4)
		 break;
		 Push(s1, tmp4);
		 
		 tmp = s -> top;
	}
	
	time_t timep;
	time(&timep);
	tmp1 -> outseconds = time(&timep);
	strcpy(tmp1 -> outtime, ctime(&timep));
	tmp1 -> fee = (tmp1 -> outseconds - tmp1 -> enterseconds) * 1;//一分钟一元
	tmp1 -> outflag = 1;
	tmp1 -> enterflag = 0;
	printf("应缴费用：%d\n", tmp1 -> fee);
	printf("离开时间：%s\n", tmp1 -> outtime);
	Pop(s);
	Push(s2, tmp1);
	tmp2 = s1 -> top;
	while(tmp2)
	{
		tmp4 = Pop(s1);
		if(NULL == tmp4)
		break;
		Push(s, tmp4);
		tmp2 = s1 -> top;
	}
	//如果等候区有车将第一辆车开进停车场
	if(FALSE == EmptyCarQueue(q))
	{
		tmp3 = DeleteCarQueue(q);
		
		if(s -> length <= 5)
		{
			
			tmp3 -> enterseconds = time(&timep);
			strcpy(tmp3 -> entertime, ctime(&timep));
			tmp3 -> enterflag = 1;
			tmp3 -> waitflag = 0;
			
			ret2 = Push(s, tmp3);
			if(SUCCESS == ret2)
			{
				printf("等候区车牌%s正在进入停车场\n", tmp3 -> carnum);
				printf("入场时间:%s\n", tmp3 -> entertime);
				printf("从等候区成功进入停车场\n");
				return SUCCESS;
			}
			else
			{
				return FAILURE;
			}
		}	
	}
	return SUCCESS;
}


int TraverseCarStack(CarStack *s, void (*p)(CarInfo *))//显示所有停车场车辆的信息
{
	if (NULL == s)
	{
		printf("1\n");
		return FAILURE;
		
	}
	//printf("2\n");
	printf("目前停车场有%d正在使用\n", s -> length);
	//printf("1\n");
	CarInfo *q = s->top;
	while (q)
	{
		p(q);
		q = q->next;
	}
	while(getchar() != '\n');
	return SUCCESS;

}


int EmptyCarStack(CarStack *s)//判断停车场是否为空
{
	if (NULL == s)
	{
		return FAILURE;
	}

	return (NULL == s->top) ? TRUE : FALSE;
}


test.c
#include"Car.h"

void visit(CarInfo *c)
{
	printf("\t\t\t车牌号：%s进库时间：%s出库时间：%s应缴费用：%d\n", c -> carnum, c -> entertime, c -> outtime, c -> fee);
	printf("\t\t\t--------------------------------------------------------------------\n");
	printf("\t\t\t--------------------------------------------------------------------\n");
}

int main()
{
	int ret, choice;
	CarStack *cs1;//车库
	CarStack *cs2;//用于临时存放
	CarStack *cs3;//用于存放离开的车辆信息
	CarQueue *cq;
	if(FAILURE == InitCarStack(&cs1) || FAILURE == InitCarStack(&cs2) || FAILURE == InitCarStack(&cs3) || FAILURE == InitCarQueue(&cq))
	{
		printf("Init Failure\n");
		exit(1);
	}
	else
	{
		Welcome();
		ret = Login();
		while( FAILURE == ret)
		{
			system("clear");
			printf("请重新登录\n");
			ret = Login();
		}
		
		while(1)
		{
			CarMenue();
			printf("\n");
			printf("请输入选项\n");
			scanf("%d", &choice);
			system("clear");
			switch(choice)
			{
				case 1: TraverseCarStack(cs1, visit);
						break;
				case 2: TraverseCarQueue(cq, visit);
						break;
				case 3: EnterCarPark(cs1, cq);
						break;
				case 4:	LeaveCarPark(cs1, cs2, cs3, cq);
						break;
				case 5: ShowByCarnum(cs1, cs3, cq, visit);
						break;
				case 6:	exit(1);
						break;
				default: printf("1111\n");
						return 0;

			}
		}
	}


	return 0;
}


秋阳2018
关注
  • 8
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
C++实现停车场管理系统
美丽世界的孤儿
01-19 1万+
有一个可以停放n 辆汽车的狭长停车场,它只有一个大门可以供车辆进出。车辆按到达停车场时间的早晚依次从停车场最里面向大门口处停放(最先到达的第一辆车放在停车场的最里面)。如果停车场已放满n 辆车,则后来的车辆只能在停车场大门外的便道上等待,一旦停车场内有车开走,则排在便道上的第一辆车就进入停车场。停车场内如有某辆车要开走,在他之后进入停车场的车都必须先退出停车场为它让路,待其开出停车场后,这些车辆在依
停车场管理系统（C语言）
M2695595362的博客
07-06 9260
使用栈和队列来做一个停车场管理系统（C语言）。
数据结构——C语言编写简单的停车场管理系统（栈和链队实现）
热门推荐
qq_44249184的博客
12-05 2万+
标题：C语言编写简单的停车场管理系统 1.问题描述 设停车场是一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出，汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端．最先到达的第一辆车停放在车场的最北端），若车场内已停满n辆汽车，则后来的汽车只能在门外的边道上等候，一旦有车离开，则排在边道上的第一辆车即可开入停车场。当停车场内某辆车要离开时，在它之后进入的车辆必须先退出车场为它让路，待该辆车开出大门外，其他车辆再按原次序进人车场，每辆停放在车场的车在它离开停车场时必须按它停留的
数据结构实验——模拟停车场系统（栈，队列）
FFFPAG的博客
06-27 2001
问题描述： 设停车场是一个可以停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆汽车停放在车场的最北端），若车场内已停满n辆车，那么后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆汽车要离开时，在它之后进入的车辆必须先退出停车场按顺序开入临时停放道为其让路，待其开出大门外后，再按原次序进入车场，每辆停放在停车场的汽车在它离开停车场时必须按其停留的时间长短缴纳费用（从进入停车
课程设计之停车场管理系统C语言实现
vivi_and_qiao的博客
01-03 8667
1.课程设计内容： 设有一个可以停放n（n&gt;=5）辆汽车的狭长停车场,它只有一个大门可以供车辆进出。车辆按到达停车场时间的早晚依次从停车场最里面向大门口处停放(最先到达的第一辆车放在停车场的最里面)。如果停车场已放满n辆车,则后来的车辆只能在停车场大门外的便道上等待,一旦停车场内有车开走,则排在便道上的第一辆车就进入停车场。停车场内如有某辆车要开走,在他之后进入停车场的车都必须先退出停车场为...
基于Linux+ARM-CotexA53+sqlite3的停车场计费系统设计与实现
最新发布
05-18
【作品名称】：基于Linux+ARM-CotexA53+sqlite3的停车场计费系统设计与实现 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目...
基于Qt的智能停车场.rar
04-28
本项目基于Qt Creator，采用C++作为编程语言，构建了一个智能停车场系统，实现了车辆管理、计时收费和图像识别等多种功能。 1. **车辆进出管理**： 在智能停车场系统中，车辆进出管理是基础功能。通过车牌识别技术...
基于QT5的停车场管理系统linux arm.rar
02-05
1、利用STM32模块连接超声波与舵机模拟真实停车杆环境 2、STM32与GEC6818开发板串口连接通信 3、车辆进入测距检测，自动触发车牌识别 4、车牌识别成功后与数据库比对是否可以入库 入库后自动更新出入库数据 6、可以...
智能停车系统（实训小项目)：QT界面设计、Linux数据库、对接百度AI车牌识别
03-31
智能停车系统是一个集成多种技术的综合应用，包括前端的用户界面设计、后台的数据处理以及人工智能技术的集成。在这个实训小项目中，我们主要关注以下几个关键知识点： 1. **QT界面设计**：QT是一个跨平台的C++图形...
模拟停车场问题
weixin_30437847的博客
11-25 743
问题描述 设停车场是一个可停放 n 辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已停满 n 辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后进入的车辆必须先退出车场为它让路，待该辆车开出大门...
停车场管理系统
01-09
设有一个可以停放n辆汽车的狭长停车场，它只有一个大门可以供车辆进出。车辆按到达停车场时间的早晚依次从停车场最里向大门口处停放（最先到达的第一辆车放在停车场的最里面）。如果停车场已放满n辆车，则后来的车只能在停车场大门外的便道上等待，一旦停车场内有车开走，则排在便道上的第一辆车就进入停车场。停车场内如有某辆车要开走，在它之后进入停车场的车都必须先退出停车场为它让路，待其开出停车场后，这些车辆再依原来的次序进场。每辆车在离开停车场时，都应根据它在停车场内停留的时间长短交费。如果停留在便道上的车未进停车场就要离去，允许其离去，不收停车费，并且仍然保持在便道上等待的车辆次序。编制一程序模拟该停车场的管理。（2） 实现要求：要求程序输出每辆车到达后的停车位置（停车场或便道上），以及某辆车离开停车场时应交纳的费用和它在停车场内停留的时间。（2） 实现提示：汽车的模拟输入信息格式可以是：（到达/离去，汽车牌照号码，到达/离去的时刻）。例如，（’A’,1,5）表示1号牌照车在5时刻到达，而（’D’,5,20）表示5号牌照车在20时刻离去。整个程序可以在输入信息为（’E’,0,0）时结束。本题可用顺序存储结构和链式存储结构来实现。本人的一个数据结构课程设计(用C＋＋源码实现，供大家学习参考之用，有不妥之处望指正)
狭长空间无线感知节点布置策略及定位算法
05-09
因为人们对无线感知节点在一些狭长空间场所的研究较少,受空间限制,无线感知节点及其网络在这些场所应用具有与开阔空间不同的特征,所以对目前应用于开阔环境下的无线感知节点定位算法进行了修正,给出了应用于狭长空间的无线感知节点定位算法。同时对狭长空间的锚节点布置方法进行了研究,给出一种较优的锚节点布置策略。理论分析、计算机仿真和实验验证表明:该算法及其锚节点布置策略在狭长空间应用中对未知节点具有很好的定位精度。
数据结构 停车场系统
12-19
停车场管理系统 设停车场是一个可停放n辆汽车的狭长通道,且只有一个大门可供汽车进出.汽车在停车场内按照车辆到达时间的先后顺序,一次由南向北排列(大门在最南端,最先到达的第一辆汽车停放在车场的最北端), 若车场内已停满n辆汽车,则后来的汽车只能在门外的便道上等候,一旦有车开走,则排在便道上的第一辆车即可开入;当停车场内的某辆车要开走时,在它之后进入的车辆必须退出车场为它让路,待该辆车开出大门外,其他车辆再按照原次序进入车场,每辆车停放在车场的车在它离开停车场时必须按照它停留的时间长短交纳费用.实为停车场编制按照上述要求进行管理的模拟程序；
数据结构c语言版课程设计停车场管理系统方案.doc
07-14
数据结构c语言版课程设计停车场管理系统方案.doc
数据结构（C语言）课设2——停车场管理（栈和队列）
qq_44629708的博客
12-16 5218
数据结构（C语言）课设2——停车场管理系统（栈和队列） 题目描述 设停车场是一个可以停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已停满n辆车，那么后来的车只能在门外的便道上等候，一旦停车场内有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后进入的...
停车场问题
10-23 956
问题描述： 设有一个可以停放n辆汽车的狭长停车场，它只有一个大门可以供车辆进出。车辆按到达停车场时间的早晚依次从停车场最里面向大门口处停放（最先到达的第一辆车放在停车场的最里面）。如果停车场已放满n辆车，则后来的车辆只能在停车场大门外的便道上等待，一旦停车场内有车开走，则排以便道 上的第一辆车就进入停车场。停车场内如有某辆车要开走，在它之后进入停车场的车都必须先退出停车场为它让路，待其开出停车
随机停车
仅做个人笔记
04-24 664
假设某段马路的指定停车区间为 [0,6] ，车长L为2，随机停车 ...#include &lt;iostream&gt; #include &lt;cstdlib&gt; #include &lt;ctime&gt; using namespace std; int L; //车长 int parking(int low, int high) { //在low~high间随机停的车的数...
停车场管理模拟系统
ZEACENT的博客
01-11 9116
1、停车场管理模拟系统 熟悉理解栈和队列的逻辑结构和存储结构，设计实现停车场管理的模拟系统，其主要内容如下： 设停车场是一个可以停放n辆汽车的狭长通道，且只有一个大门可供汽车进出，其模型如下图所示。 汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆汽车停放在车场的最北端），若车场内已停满n辆车，那么后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上...
1) 在linux平台上搭建makefile工程编写一个“停车场车位显示系统”终端程序;
05-13
要在linux平台上搭建makefile工程编写一个“停车场车位显示系统”终端程序，需要按以下步骤进行： 1. 确定所需的开发工具和语言：根据需求，选择合适的编程语言和工具。推荐选择C语言，因为它在Linux平台上广泛使用且易于开发和编译。 2. 创建makefile文件：在Linux平台上开发程序，最好使用makefile来自动化编译、链接和构建。makefile是一种文本文件，其中包含项目的编译规则和命令。 3. 设计程序框架：考虑程序需要完成的功能和使用情形，设计程序的结构和算法。通常需要采用模块化的编程方法，将程序分为多个模块，每个模块负责不同的任务。 4. 编写程序代码：根据程序的设计思路，编写程序代码，并将它们保存在合适的文件中。代码应该注重可读性和可维护性，遵循良好的编程规范和习惯。 5. 编译程序：通过makefile文件编译程序，将所有代码文件和库文件链接在一起生成可执行程序。 6. 测试和调试程序：运行程序进行测试，并对程序进行调试，以确保程序功能的正确性和稳定性。 7. 部署程序：在测试和调试完成后，将程序部署到Linux平台上，以供使用。 总之，搭建一个“停车场车位显示系统”终端程序需要仔细考虑设计和实现，理解Linux平台上的开发工具和语言，并按照上述步骤进行开发和编译。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值