停车场管理系统源码_开源停车场管理系统

文章目录：

• 1、C语言停车场管理系统
• 2、跪求JAVA编写的停车场管理系统源代码
• 3、用JAVA怎么编写停车场管理系统源代码？
• 4、你好，能否给我一份停车场管理系统的源码，我一直寻找。谢谢QQ815856230
• 5、跪求停车场管理系统源代码，注意是javaweb
• 6、求智能停车场管理系统的源代码

C语言停车场管理系统

/*----------------------------------------------------------------

// Copyright (C) 2009 沈阳工程学院信息安全工作室

// 版权所有。

//

// 文件名：模拟停车场问题.cpp

// 文件功能描述：模拟停车场问题

//

//

// 创建标识：20091214

//

// 修改标识：20091218

// 修改描述：完成编码

//----------------------------------------------------------------*/

//头文件

#include iostream

#include malloc.h

#include string

#include windows.h

//常量定义

#define MAX_STOP 4 //定义停车场最大停车数

#define MAX_PLATE 10 //定义车牌号最大长度

#define TIME_COUNT "秒" //定义时间单位

#define TIME_MS_TO_CONUT 1000 //定义时间进制，意为由TIME_COUNT到毫秒的进制

#define UNIT_PRICE 10 //定义单位时间收费标准

using namespace std; //使用std命名空间

//数据结构定义

//定义存储汽车信息的结构体

typedef struct

{

char license_plate[MAX_PLATE]; //汽车牌照号码，定义为一个字符指针类型

char state; //汽车当前状态，字符p表示停放在停车位上，字符s表示停放在便道上，每辆车的初始状态用字符i来进行表示

int time; //汽车停入停车场时的时间，用来计时收费

}CAR;

//定义模拟停车场的栈结构

typedef struct

{

CAR STOP[MAX_STOP]; //汽车信息的存储空间

int top; //用来指示栈顶位置的静态指针

}SeqStack;

//定义模拟便道的队列结构

typedef struct node

{

CAR WAIT; //汽车信息的存储空间

struct node *next; //用来指示队列位置的动态指针

}QNode; //链队列节点的类型

//定义链队列的收尾指针

typedef struct

{

QNode *front,*rear;

}LQueue; //将头尾指针封装在一起的链队

//函数声明

int Empty_LQueue(LQueue *q); //判队空

int LeaveCheck(SeqStack parking , char *license_plate); //检查离开的车是否在停车场中

int QueueLength(LQueue *q); //判队长度

int Out_LQueue(LQueue *sidewalk , char *license_plate); //出队操作

int StackEmpty(SeqStack parking); //判断栈是否为空

int StackFull(SeqStack parking); //判断栈是否为满

int StackPop(SeqStack parking); //出栈操作

int StackTop(SeqStack parking , char *license_plate , int time);//取栈顶元素

void Car_come(SeqStack parking , LQueue *sidewalk); //有车到来时的操作

void Car_leave(SeqStack parking , LQueue *sidewalk); //有车离开的操作

void Display(SeqStack parking); //显示停车场内的所有信息 调试时用

void InitStack(SeqStack parking); //初始化栈

void InitList(LQueue *sidewalk); //初始化队列

void In_LQueue(LQueue *sidewalk , char *license_plate); //进队操作

void Input_Check(char *license_plate); ////检验输入的车牌是否合法

void StackPush(SeqStack parking , char *license_plate , int stop_time);//进栈操作

void main()

{

//定义变量

SeqStack parking;

LQueue *sidewalk = NULL;

char *choice = new char;

int flag = 1; //定义一个变量 判断是否退出

//初始化一个为空的停车场

InitStack(parking);

//初始化一个为空的便道

InitList(sidewalk);

//运行界面及功能选择

while(flag)

{

cout"\n\t 停车场模拟管理系统 \n\n";

cout"\t|--------------------------------------------------|\n\n";

cout"\t|本程序为停车场的模拟管理系统，有车到来时请按C键。|\n\n";

cout"\t|然后根据屏幕提示进行相关操作，有车要走时请按l键。|\n\n";

cout"\t|然后根据屏幕提示进行相关操作，查看停车场请按D键。|\n\n";

cout"\t|然后根据屏幕提示进行相关操作，要退出系统请按Q键。|\n\n";

cout"\t|--------------------------------------------------|\n\n";

cout"请选择操作：";

gets(choice);

if(1 != strlen(choice))

{

cout"请正确输入选项!";

continue;

}

else

{

switch(*choice)

{

case 'c':

case 'C':

{

Car_come(parking,sidewalk);break;

}

case 'l':

case 'L':

{

Car_leave(parking,sidewalk);break;

}

case 'q':

case 'Q':

{

flag=0;break;

}

case 'd':

case 'D':

{

Display(parking);break;

}

default:

cout"选择不正确！请重新选择！\n";

}

}

}

}

//有车到来时的操作

void Car_come(SeqStack parking , LQueue *sidewalk)

{

//定义变量

char license_plate[MAX_PLATE];

cout"请输入车辆的车牌号码：";

Input_Check(license_plate);

//判断停车场是否已满，满则进入便道，不满进入停车场

if(StackFull(parking))

{

In_LQueue(sidewalk , license_plate); //进入便道

cout"停车场已满请在便道等候,您的位置为"QueueLength(sidewalk)

endl;

}

else

{

StackPush(parking , license_plate , GetTickCount()); //进入停车场

cout"请进入停车场中的"parking.top+1"号停车位\n";

}

// Display(parking);

}

//有车离开时的操作

void Car_leave(SeqStack parking , LQueue *sidewalk)

{

//定义变量

SeqStack tmpparking; //定义临时停车场

char leave_license_plate[MAX_PLATE]; //要离开的车牌号

char license_plate[MAX_PLATE]; //存放从停车场中读出来的车牌信息

int time;

InitStack(tmpparking); //初始化临时停车场

//判断停车场中是否有车

if(StackEmpty(parking))

{

cout"当前停车场中没有车\n";

return; //退出子函数

}

cout"请输入要离开的车牌照：";

Input_Check(leave_license_plate);

cout"当前停车场中有"parking.top+1"辆车\n";

if(LeaveCheck(parking , leave_license_plate)) //判断车是否在停车场中

{

//车在停车场中

cout"您的车在"LeaveCheck(parking , leave_license_plate)"号车位上\n";

while(StackTop(parking , license_plate , time)

(strcmp(parking.STOP[parking.top].license_plate , leave_license_plate) != 0))

{

strcpy(parking.STOP[parking.top].license_plate , license_plate);

cout"牌照为"license_plate"的车暂时退出停车场"parking.top+1"号位\n";

StackPush(tmpparking , license_plate , time); //停车场中的车暂时退出 进入临时停车场

StackPop(parking); //出栈

}

cout"牌照为"license_plate"的车离开停车场"parking.top+1"号位\n";

cout"您在停车场中停了"(GetTickCount()-time)/TIME_MS_TO_CONUTTIME_COUNTendl; //输出所停时间信息

cout"应缴费用为"(GetTickCount()-time)/TIME_MS_TO_CONUT*UNIT_PRICE"元\n";; //输出费用信息

StackPop(parking); //出栈

//将临时停车场中的车停回停车场

while(StackEmpty(tmpparking) != 1)

{

StackTop(tmpparking , license_plate , time);

StackPush(parking , license_plate , time);

cout"牌照为"license_plate"的车进入停车场"parking.top+1"号位\n";

license_plate[0] = '\0';

StackPop(tmpparking);

}

if(parking.top+1 == MAX_STOP-1) //判断车离开前停车场是否停满

if(QueueLength(sidewalk)) //如果停满则判断便道上是否有车

{

//便道中有车 则从便道中停入停车场

Out_LQueue(sidewalk , license_plate); //出队

StackPush(parking , license_plate , GetTickCount()); //入栈

cout"在便道中牌照为"license_plate"的车进入停车场"parking.top+1"号位\n";

}

}

else

//车不在停车场中

cout"您的车不在停车场中！\n";

}

//初始化顺序栈

void InitStack(SeqStack parking)

{

parking.top = -1;

}

//判栈空

int StackEmpty(SeqStack parking)

{

if(parking.top == -1)

return 1;

else

return 0;

}

//判栈满

int StackFull(SeqStack parking)

{

if(parking.top == MAX_STOP-1)

return 1;

else

return 0;

}

//入栈

void StackPush(SeqStack parking , char *license_plate , int stop_time)

{

parking.top++;

strcpy(parking.STOP[parking.top].license_plate , license_plate);

parking.STOP[parking.top].state = 'p';

parking.STOP[parking.top].time = stop_time;

}

//出栈 返回栈顶指针

int StackPop(SeqStack parking)

{

if(StackEmpty(parking))

return 0;

else

return parking.top--;

}

//取栈顶元素

int StackTop(SeqStack parking , char *license_plate , int time)

{

if(StackEmpty(parking))

return 0;

else

{

strcpy(license_plate , parking.STOP[parking.top].license_plate);

time = parking.STOP[parking.top].time;

return 1;

}

}

//显示所有

void Display(SeqStack parking)

{

if(parking.top == -1)

printf("停车场为空\n");

else

{

while(parking.top != -1)

{

cout"车牌号为："parking.STOP[parking.top].license_plate;

cout"，停在"parking.top + 1 "号车位上";

cout"，已停"(GetTickCount()-parking.STOP[parking.top].time)/TIME_MS_TO_CONUTTIME_COUNTendl;

parking.top--;

}

}

}

//初始化队列

void InitList(LQueue *sidewalk)

{

sidewalk = (LQueue *)malloc(sizeof(LQueue));

sidewalk-front=sidewalk-rear = NULL;

}

//入队

void In_LQueue(LQueue *sidewalk,char *license_plate)

{

QNode *car_on_sidewalk;

car_on_sidewalk = (QNode *)malloc(sizeof(QNode)); //为新节点开辟新空间

strcpy(car_on_sidewalk-WAIT.license_plate , license_plate); //将数据写入节点

car_on_sidewalk-WAIT.state = 's'; //写入停车信息

car_on_sidewalk-WAIT.time = GetTickCount(); //写入停车时间

car_on_sidewalk-next = NULL;

if(Empty_LQueue(sidewalk)) //队空则创建第一个节点

sidewalk-front = sidewalk-rear = car_on_sidewalk;

else

{

//队非空插入队尾

sidewalk-rear-next = car_on_sidewalk;

sidewalk-rear = car_on_sidewalk;

}

}

//判队空

int Empty_LQueue(LQueue *q)

{

if(q-front == NULL)

return 1;

else

return 0;

}

//判队长度 返回队长

int QueueLength(LQueue *q)

{

QNode *p=q-front;

int i=0;

while(p != NULL)

{

i++;

p=p-next;

}

return i;

}

//出队 成功返回1 队空返回0

int Out_LQueue(LQueue *sidewalk,char *license_plate)

{

QNode *car_on_sidewalk;

if(Empty_LQueue(sidewalk)) //如果队空返回0

return 0;

car_on_sidewalk = sidewalk-front;

strcpy(license_plate , car_on_sidewalk-WAIT.license_plate);//取出队头元素

if(sidewalk-front == sidewalk-rear) //队中只有一个元素

sidewalk-front = sidewalk-rear=NULL; //删除元素

else

sidewalk-front = sidewalk-front-next; //队头指针后移

free(car_on_sidewalk); //释放指针

return 1;

}

//检查离开的车是否在停车场中 返回车在停车场中位置 不在则返回0

int LeaveCheck(SeqStack parking,char *license_plate)

{

int flag = parking.top+1; //定义变量记录当前车在停车场中位置

if(StackEmpty(parking))

return 0;

else

{

//查找离开车所在位置

while(parking.top != -1 strcmp(parking.STOP[parking.top].license_plate , license_plate) != 0)

{

flag--;

parking.top--;

}

return flag;

}

}

//检验输入的车牌是否合法

void Input_Check(char *license_plate)

{

int flag = 1;

int i;

string tmpstr;

while(flag)

{

cintmpstr;

getchar();

if(tmpstr.length()MAX_PLATE)

{

for(i=0;i10;i++)

license_plate[i] = tmpstr.c_str()[i];

flag = 0;

}

else

cout"输入有误，请重新输入：";

}

}

以前的课设 你看看吧 纯手工的~~

跪求JAVA编写的停车场管理系统源代码

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Scanner;

/*********************************

* 停车场管理

* author zhang

*2013-12-13

********************************/

public class CarStopManager {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("请入车牌号:");

String carno = sc.next();

CarStopManager carStopManager = new CarStopManager();

carStopManager.setCarNo(carno);//设置车牌号

SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

String sdate = format.format(new Date());

System.out.println("当前时间（入场时间）是: "+sdate);

System.out.println("需要开出车场吗？yes/no:");

String yesno = sc.next();

if(yesno.equals("yes")){

String edate = format.format(new Date());

System.out.println("出场时间是: "+edate);

//计算方法

carManager(2, sdate, edate,carStopManager);

}

}

/**

* 计算方法

*/

public static void carManager(int type,String starTime,

String endTime,CarStopManager carStopManager){

if(type==1){//按月收费

System.out.println("如若没有缴纳月费请缴纳800元，如若缴纳将不再提示!");

}else{

/**

* 一般不会有停车几个月的吧？先不考虑停车几年或者几个月的

*/

String sDay = starTime.substring(8,10);//入场日期（天）

String sHour = starTime.substring(11, 13);//入场小时

String sMM = starTime.substring(14,16);//入场分钟

String eDay = starTime.substring(8,10);//出场日期（天）

String eHour = endTime.substring(11, 13);//出厂小时

String eMM = endTime.substring(14,16);//出厂分钟

float money = 0;//需缴纳的费用

int shour = Integer.parseInt(sHour);

int ehour = Integer.parseInt(eHour);

int smm = Integer.parseInt(sMM);

int emm = Integer.parseInt(eMM);

int rehour = 0;//停车几个小时

if(sDay.equals(eDay)){//同一天

//当天6点到20点之间

if((shour=6 shour=20)){

if(ehour - shour=6){//6个小时之内

rehour = (ehour - shour)*60+(emm - smm);//停车多少分钟

//需要缴纳的费用 前15分钟免费 以后每15分钟1.5元

money = (rehour/15-15)*1.5f;

}else{

int hour = ehour - shour -6;//6小时除外剩余小时数

rehour = 6*60+(emm - smm);//停车多少分钟

//前15分钟免费 以后每15分钟1.5元 超过6小时15分钟2元

money = ((rehour/15-15)*1.5f)+(hour*60/2);

}

}

}else{//跨天 20点到 6点之间

//todo

}

System.out.println("您的车牌号是:"+carStopManager.getCarNo()+";\n" +

"您此次停车花费的费用是: "+money+"元");

}

}

/**

* bean属性

*/

private String carNo;//车牌号

private String startTime;//入场时间

private String endTime;//出场时间

/**

* 无参构造

*/

public CarStopManager(){

super();

}

/**

* 有参数构造

* @param carNo

* @param startTime

* @param endTime

*/

public CarStopManager(String carNo, String startTime, String endTime) {

super();

this.carNo = carNo;

this.startTime = startTime;

this.endTime = endTime;

}

/**

* 设置get方法

* @return

*/

public String getCarNo() {

return carNo;

}

/**

* 设置set方法

* @param carNo

*/

public void setCarNo(String carNo) {

this.carNo = carNo;

}

public String getStartTime() {

return startTime;

}

public void setStartTime(String startTime) {

this.startTime = startTime;

}

public String getEndTime() {

return endTime;

}

public void setEndTime(String endTime) {

this.endTime = endTime;

}

}

用JAVA怎么编写停车场管理系统源代码？

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Scanner;

/*********************************

* 停车场管理

* author zhang

*2013-12-13

********************************/

public class CarStopManager {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("请入车牌号:");

String carno = sc.next();

CarStopManager carStopManager = new CarStopManager();

carStopManager.setCarNo(carno);//设置车牌号

SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

String sdate = format.format(new Date());

System.out.println("当前时间（入场时间）是: "+sdate);

System.out.println("需要开出车场吗？yes/no:");

String yesno = sc.next();

if(yesno.equals("yes")){

String edate = format.format(new Date());

System.out.println("出场时间是: "+edate);

//计算方法

carManager(2, sdate, edate,carStopManager);

}

}

/**

* 计算方法

*/

public static void carManager(int type,String starTime,

String endTime,CarStopManager carStopManager){

if(type==1){//按月收费

System.out.println("如若没有缴纳月费请缴纳800元，如若缴纳将不再提示!");

}else{

/**

* 一般不会有停车几个月的吧？先不考虑停车几年或者几个月的

*/

String sDay = starTime.substring(8,10);//入场日期（天）

String sHour = starTime.substring(11, 13);//入场小时

String sMM = starTime.substring(14,16);//入场分钟

String eDay = starTime.substring(8,10);//出场日期（天）

String eHour = endTime.substring(11, 13);//出厂小时

String eMM = endTime.substring(14,16);//出厂分钟

float money = 0;//需缴纳的费用

int shour = Integer.parseInt(sHour);

int ehour = Integer.parseInt(eHour);

int smm = Integer.parseInt(sMM);

int emm = Integer.parseInt(eMM);

int rehour = 0;//停车几个小时

if(sDay.equals(eDay)){//同一天

//当天6点到20点之间

if((shour=6 shour=20)){

if(ehour - shour=6){//6个小时之内

rehour = (ehour - shour)*60+(emm - smm);//停车多少分钟

//需要缴纳的费用 前15分钟免费 以后每15分钟1.5元

money = (rehour/15-15)*1.5f;

}else{

int hour = ehour - shour -6;//6小时除外剩余小时数

rehour = 6*60+(emm - smm);//停车多少分钟

//前15分钟免费 以后每15分钟1.5元 超过6小时15分钟2元

money = ((rehour/15-15)*1.5f)+(hour*60/2);

}

}

}else{//跨天 20点到 6点之间

//todo

}

System.out.println("您的车牌号是:"+carStopManager.getCarNo()+";\n" +

"您此次停车花费的费用是: "+money+"元");

}

}

/**

* bean属性

*/

private String carNo;//车牌号

private String startTime;//入场时间

private String endTime;//出场时间

/**

* 无参构造

*/

public CarStopManager(){

super();

}

/**

* 有参数构造

* @param carNo

* @param startTime

* @param endTime

*/

public CarStopManager(String carNo, String startTime, String endTime) {

super();

this.carNo = carNo;

this.startTime = startTime;

this.endTime = endTime;

}

/**

* 设置get方法

* @return

*/

public String getCarNo() {

return carNo;

}

/**

* 设置set方法

* @param carNo

*/

public void setCarNo(String carNo) {

this.carNo = carNo;

}

public String getStartTime() {

return startTime;

}

public void setStartTime(String startTime) {

this.startTime = startTime;

}

public String getEndTime() {

return endTime;

}

public void setEndTime(String endTime) {

this.endTime = endTime;

}

}

你好，能否给我一份停车场管理系统的源码，我一直寻找。谢谢QQ815856230

把扩展名改成CPP,然后编译连接

///////////////////////////////

下面这个程序是我大二上数据结构课时交的作业,现在正好电脑里面放着,所以就给你,应该满足你老师的要求了.编译环境是 VC++ 6.0

如果不会用的话就在问题补充里说,那个"例"是我临时给你打上去的,随便写了点,你要看不懂例子不会输命令就问我.

/*****************************************************************/

#include conio.h

#include malloc.h

#include stdio.h

#include stdlib.h

#include windows.h

// 清空当前屏幕

#define ClearScreen() system( "cls" )

// 显示字符串 szPrompt 并等待用户按下任意键

#define Pause( szPrompt ) printf( "%s", szPrompt ),getch()

typedef struct carinformation // 车辆信息

{

char szRegistrationMark[64]; // 车牌号

char szArrivalTime[16]; // 到达时间

char szEntranceTime[16]; // 进入停车场(开始计费)时间

char szDepartureTime[16]; // 离开时间

} TCARINFORMATION, *LPTCARINFORMATION;

typedef struct carstack

{

LPTCARINFORMATION lpCarInformation; // 车辆信息

int nTop; // 栈顶元素下标

int nStackSize; // 栈容量

} TCARSTACK, *LPTCARSTACK;

// 初始化栈 lpCarStack, 将其容量设置为 nSize

void InitStack( LPTCARSTACK lpCarStack, int nSize )

{

lpCarStack = ( LPTCARSTACK ) malloc( sizeof ( TCARSTACK ) );

lpCarStack-lpCarInformation = ( LPTCARINFORMATION ) malloc(

nSize * sizeof ( TCARINFORMATION )

);

lpCarStack-nTop = -1;

lpCarStack-nStackSize = nSize;

}

// 车辆信息 carinfo 入栈 lpCarStack

void Push( LPTCARSTACK lpCarStack, TCARINFORMATION carinfo )

{

lpCarStack-nTop++;

lpCarStack-lpCarInformation[lpCarStack-nTop] = carinfo;

}

// 车辆信息从栈 lpCarStack 中弹出并存入 carinfo

void Pop( LPTCARSTACK lpCarStack, TCARINFORMATION carinfo )

{

carinfo = lpCarStack-lpCarInformation[lpCarStack-nTop];

lpCarStack-nTop--;

}

// 若栈 lpCarstack 空,返回 TRUE;否则,返回 FALSE

BOOL IsStackEmpty( LPTCARSTACK lpCarStack )

{

return lpCarStack-nTop == -1;

}

// 若栈 lpStackFull 满,返回 TRUE;否则,返回 FALSE

BOOL IsStackFull( LPTCARSTACK lpCarStack )

{

return lpCarStack-nTop == ( lpCarStack-nStackSize - 1 );

}

// 销毁栈 lpCarStack,将指针 lpCarStack 置为 NULL

void DestroyStack( LPTCARSTACK lpCarStack )

{

free( lpCarStack-lpCarInformation );

free( lpCarStack );

lpCarStack = NULL;

}

typedef struct carnode // 链队结点信息

{

TCARINFORMATION carinfo; // 车辆信息

struct carnode *lpNext; // 指向下一个元素的指针

} TCARNODE, *LPTCARNODE;

typedef struct carqueue // 链队

{

LPTCARNODE lpHead; // 头结点

LPTCARNODE lpRear; // 指向当前队尾的指针

int nEffectiveSize; // 当前队中元素个数

} TCARQUEUE, *LPTCARQUEUE;

// 初始化链队 lpCarQueue

void InitQueue( LPTCARQUEUE lpCarQueue )

{

lpCarQueue = ( LPTCARQUEUE ) malloc( sizeof( TCARQUEUE ) );

lpCarQueue-lpHead = ( LPTCARNODE) malloc( sizeof( TCARNODE ) );

lpCarQueue-lpHead-lpNext = NULL;

lpCarQueue-lpRear = lpCarQueue-lpHead;

lpCarQueue-nEffectiveSize = 0;

}

// 车辆信息 carinfo 入队 lpCarQueue

void EnQueue( LPTCARQUEUE lpCarQueue, TCARINFORMATION carinfo )

{

LPTCARNODE lpCarNode = ( LPTCARNODE ) malloc( sizeof( carnode ) );

lpCarNode-carinfo = carinfo;

lpCarNode-lpNext = NULL;

lpCarQueue-lpRear-lpNext = lpCarNode;

lpCarQueue-lpRear = lpCarQueue-lpRear-lpNext;

lpCarQueue-nEffectiveSize++;

}

// 队头元素从链队 lpCarQueue 中出队并存入 carinfo

void DeQueue( LPTCARQUEUE lpCarQueue, TCARINFORMATION carinfo )

{

LPTCARNODE lpTemp = lpCarQueue-lpHead-lpNext;

carinfo = lpTemp-carinfo;

lpCarQueue-lpHead-lpNext = lpTemp-lpNext;

free( lpTemp );

lpCarQueue-nEffectiveSize--;

}

// 若链队 lpCarQueue 为空,返回 TRUE;否则,返回 FALSE

BOOL IsQueueEmpty( LPTCARQUEUE lpCarQueue )

{

return lpCarQueue-nEffectiveSize == 0;

}

// 销毁链队 lpCarQueue

void DestroyQueue( LPTCARQUEUE lpCarQueue )

{

LPTCARNODE lpNextCarNode = NULL;

for ( LPTCARNODE lpCarNode = lpCarQueue-lpHead; lpCarNode != NULL; lpCarNode = lpNextCarNode )

{

lpNextCarNode = lpCarNode-lpNext;

free( lpCarNode );

}

free( lpCarQueue );

lpCarQueue = NULL;

}

// 将字符串时间格式转换为数字(分钟)格式,例如 12:36 将被转换为 756 ( 12 * 60 + 36 )

int ConvertTimeFormat( char *lpTime )

{

int nHour = 0;

int nMinute = 0;

sscanf( lpTime, "%d:%d", nHour, nMinute );

return nHour * 60 + nMinute;

}

// 根据在停车场内的停留时间 nContinuanceMinutes (分钟)计算费用

double CalculateExpense( int nContinuanceMinutes )

{

return nContinuanceMinutes * ( 5.0 / 60 );

}

int main( void )

{

int nParkCapability = 0; // 停车场容量

putchar( '\n' );

printf( "请输入停车场容量:" );

scanf( "%d", nParkCapability );

LPTCARSTACK lpCarStack = NULL; // 停车场,用栈模拟

InitStack( lpCarStack, nParkCapability );

LPTCARQUEUE lpCarQueue = NULL; // 便道,用链队模拟

InitQueue( lpCarQueue );

char cCommandType = NULL; // 命令类型

char szUserInput[128] = { NULL }; // 用户输入

do

{

ClearScreen();

putchar( '\n' );

puts( "--------------------" );

puts( "[命令类型]" );

puts( "A - 车辆到达" );

puts( "D - 车辆离开" );

puts( "E - 停止输入" );

puts( "O - 显示当前停车场和便道使用情况" );

putchar( '\n' );

puts( "例:" );

puts( "A,冀A1234,14:26" );

puts( "D,冀A1234,16:51" );

puts( "E" );

puts( "O" );

putchar( '\n' );

printf( "请输入命令:" );

scanf( "%s", szUserInput );

puts( "--------------------" );

char szCarInformation[128] = { NULL };

sscanf( szUserInput, // 将命令类型与车辆信息分开存放

"%c,%s",

cCommandType, // 用户输入的前半部分,即命令类型

szCarInformation // 用户输入的后半部分,即车辆信息

);

char *lpCommaLocation = NULL; // 车辆信息字符串中的逗号位置

for ( lpCommaLocation = szCarInformation; *lpCommaLocation != '\0'; lpCommaLocation++ )

{

if ( *lpCommaLocation == ',' )

{

break;

}

}

*lpCommaLocation = '\0';

TCARINFORMATION carinfo = { NULL }; // 存储本次用户输入的车辆信息

strcpy( carinfo.szRegistrationMark, szCarInformation );

if ( cCommandType == 'A' )

{

strcpy( carinfo.szArrivalTime, lpCommaLocation + 1 );

if ( FALSE == IsStackFull( lpCarStack ) )

{

strcpy( carinfo.szEntranceTime, carinfo.szArrivalTime );

Push( lpCarStack, carinfo );

printf( "已进入停车场第 %d 个车位\n",

lpCarStack-nTop + 1

);

printf( "车牌号:\t\t%s\n", carinfo.szRegistrationMark );

printf( "进入时间:\t%s\n", carinfo.szEntranceTime );

puts( "是否收费:\t是" );

}

else

{

EnQueue( lpCarQueue, carinfo );

printf( "停车场已满,已停放在便道的第 %d 个车位\n",

lpCarQueue-nEffectiveSize

);

printf( "车牌号:\t\t%s\n", carinfo.szRegistrationMark );

printf( "停放时间:\t%s\n", carinfo.szArrivalTime );

puts( "是否收费:\t否" );

}

}

else if ( cCommandType == 'D' )

{

strcpy( carinfo.szDepartureTime, lpCommaLocation + 1 );

LPTCARSTACK lpTempCarStack = NULL;

InitStack( lpTempCarStack, nParkCapability );

TCARINFORMATION carinfoOut = { NULL };

BOOL bIsCarFound = FALSE;

while ( FALSE == IsStackEmpty( lpCarStack ) )

{

Pop( lpCarStack, carinfoOut );

if ( 0 != strcmp( carinfoOut.szRegistrationMark, carinfo.szRegistrationMark ) )

{

Push( lpTempCarStack, carinfoOut );

}

else

{

bIsCarFound = TRUE;

break;

}

}

while ( FALSE == IsStackEmpty( lpTempCarStack ) )

{

TCARINFORMATION tempcarinfo = { NULL };

Pop( lpTempCarStack, tempcarinfo );

Push( lpCarStack, tempcarinfo );

}

if ( FALSE == bIsCarFound )

{

printf( "车牌号为 %s 的车未进入停车场.\n", carinfo.szRegistrationMark );

Pause( "--------------------\n按任意键输入下一条信息...\n" );

continue;

}

strcpy( carinfoOut.szDepartureTime, carinfo.szDepartureTime );

int nEntranceTime = ConvertTimeFormat( carinfoOut.szEntranceTime );

int nDepartureTime = ConvertTimeFormat( carinfoOut.szDepartureTime );

int nContinuanceMinutes = nDepartureTime - nEntranceTime;

printf( "计费时段:\t%s - %s (共 %d 分钟)\n",

carinfoOut.szEntranceTime,

carinfoOut.szDepartureTime,

nContinuanceMinutes

);

double rExpense = CalculateExpense( nContinuanceMinutes );

printf( "应交纳的费用:\t%.1lf 元\n", rExpense );

if ( FALSE == IsQueueEmpty( lpCarQueue ) )

{

TCARINFORMATION tempcarinfo = { NULL };

DeQueue( lpCarQueue, tempcarinfo );

strcpy( tempcarinfo.szEntranceTime, carinfoOut.szDepartureTime );

Push( lpCarStack, tempcarinfo );

puts( "--------------------" );

printf( "停放在便道的第 1 个车位,车牌号为 %s 的车已进入停车场\n",

tempcarinfo.szRegistrationMark

);

}

}

else if ( cCommandType == 'E' )

{

puts( "********************" );

puts( "陈赛 - Build20090507\n" );

puts( "********************" );

break;

}

else if ( cCommandType == 'O' )

{

ClearScreen();

putchar( '\n' );

puts( "[停车场使用情况]\n" );

puts( "[车位]\t[车牌号]\t[到达时间]\t[进入(开始计费)时间]\n");

for ( int i = 0; i = lpCarStack-nTop; i++ )

{

printf( "%d\t%s\t\t%s\t\t%s\n",

i + 1,

lpCarStack-lpCarInformation[i].szRegistrationMark,

lpCarStack-lpCarInformation[i].szArrivalTime,

lpCarStack-lpCarInformation[i].szEntranceTime

);

}

putchar( '\n' );

putchar( '\n' );

putchar( '\n' );

puts( "[便道使用情况]\n" );

puts( "[车位]\t[车牌号]\t[到达时间]\t[进入(开始计费)时间]\n");

int nNum = 0;

for ( LPTCARNODE lpCarNode = lpCarQueue-lpHead-lpNext;

lpCarNode != NULL; lpCarNode = lpCarNode-lpNext )

{

nNum++;

printf( "%d\t%s\t\t%s\t\t%s\n",

nNum,

lpCarNode-carinfo.szRegistrationMark,

lpCarNode-carinfo.szArrivalTime,

lpCarNode-carinfo.szEntranceTime

);

}

putchar( '\n' );

}

else

{

puts( "输入信息有误.第一个字符只能为 'A' 或 'D' 或 'E' 或 'O' (区分大小写)." );

}

Pause( "--------------------\n按任意键输入下一条信息.\n" );

} while ( TRUE );

DestroyStack( lpCarStack );

DestroyQueue( lpCarQueue );

Pause( "\n按任意键退出程序...\n" );

return 0;

}

// 车辆进入用 A 命令,格式如下:

// A,牌照,时间 例如: A,12345,13:52

// 离开用 D 命令, 例如: D,12345,14:53

// 查看当前停车场情况,用英文字母O命令 直接输入O即可,

// 结束,直接输入E

跪求停车场管理系统源代码，注意是javaweb

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Scanner;

/*********************************

* 停车场管理

* author zhang

*2013-12-13

********************************/

public class CarStopManager {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("请入车牌号:");

String carno = sc.next();

CarStopManager carStopManager = new CarStopManager();

carStopManager.setCarNo(carno);//设置车牌号

SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

String sdate = format.format(new Date());

System.out.println("当前时间（入场时间）是: "+sdate);

System.out.println("需要开出车场吗？yes/no:");

String yesno = sc.next();

if(yesno.equals("yes")){

String edate = format.format(new Date());

System.out.println("出场时间是: "+edate);

//计算方法

carManager(2, sdate, edate,carStopManager);

}

}

/**

* 计算方法

*/

public static  void carManager(int type,String starTime,

String endTime,CarStopManager carStopManager){

if(type==1){//按月收费

System.out.println("如若没有缴纳月费请缴纳800元，如若缴纳将不再提示!");

}else{

/**

* 一般不会有停车几个月的吧？先不考虑停车几年或者几个月的

*/

String sDay = starTime.substring(8,10);//入场日期（天）

String sHour = starTime.substring(11, 13);//入场小时

String sMM = starTime.substring(14,16);//入场分钟

String eDay = starTime.substring(8,10);//出场日期（天）

String eHour = endTime.substring(11, 13);//出厂小时

String eMM = endTime.substring(14,16);//出厂分钟

float money = 0;//需缴纳的费用

int shour = Integer.parseInt(sHour);

int ehour = Integer.parseInt(eHour);

int smm = Integer.parseInt(sMM);

int emm = Integer.parseInt(eMM);

int rehour = 0;//停车几个小时

if(sDay.equals(eDay)){//同一天

 //当天6点到20点之间

if((shour=6 shour=20)){

if(ehour - shour=6){//6个小时之内

rehour = (ehour - shour)*60+(emm - smm);//停车多少分钟

//需要缴纳的费用 前15分钟免费 以后每15分钟1.5元

money = (rehour/15-15)*1.5f;

}else{

int hour = ehour - shour -6;//6小时除外剩余小时数

rehour = 6*60+(emm - smm);//停车多少分钟

//前15分钟免费 以后每15分钟1.5元 超过6小时15分钟2元

money = ((rehour/15-15)*1.5f)+(hour*60/2);

    }

}

}else{//跨天 20点到 6点之间

//todo

}

System.out.println("您的车牌号是:"+carStopManager.getCarNo()+";\n" +

"您此次停车花费的费用是: "+money+"元");

}

}

/**

* bean属性

*/

private String carNo;//车牌号

private String startTime;//入场时间

private String endTime;//出场时间

/**

* 无参构造

*/

public CarStopManager(){

super();

}

/**

* 有参数构造

* @param carNo

* @param startTime

* @param endTime

*/

public CarStopManager(String carNo, String startTime, String endTime) {

super();

this.carNo = carNo;

this.startTime = startTime;

this.endTime = endTime;

}

/**

* 设置get方法

* @return

*/

public String getCarNo() {

return carNo;

}

   /**

    * 设置set方法

    * @param carNo

    */

public void setCarNo(String carNo) {

this.carNo = carNo;

}

public String getStartTime() {

return startTime;

}

public void setStartTime(String startTime) {

this.startTime = startTime;

}

public String getEndTime() {

return endTime;

}

public void setEndTime(String endTime) {

this.endTime = endTime;

}

}

求智能停车场管理系统的源代码

#include "stdio.h"

#include "stdlib.h"

#define n 100

#define NULL 0

typedef struct

{

int data[n];

int top;

}sqstack;

void initstack(sqstack *s)

{

s=new sqstack;

s-top=-1;

}

int push(sqstack *s,int e)

{

if(s-top==n-1)

return 0;

s-top++;

s-data[s-top]=e;

return 1;

}

int pop(sqstack *s,int x)

{

int a[n],e,i=0,j;

if(s-top==-1)

{

printf("停车场是空的！\n");

return 0;

}

while(s-data[s-top]!=x)

{

e=s-data[s-top];

s-top--;

if(s-top==-1)

{

printf("你要找的车辆不在停车场内\n");

return 0;

}

a[i]=e;

i++;

}

s-top--;

for(j=i-1;j=0;j--)

{

s-top++;

s-data[s-top]=a[j];

}

return (s-top);

}

void dispstack(sqstack *s)

{

int i;

for(i=s-top;i=0;i--)

printf("%4d",s-data[i]);

printf("\n");

}

void main()

{

int x,y,i=0;

sqstack *s=NULL;

initstack(s);

do

{

printf("请输入命令(1、到达；2、离开；3、浏览停车场；0、退出)及车牌号\n");

scanf("%d",y);

switch(y)

{

case 1:

{

scanf("%d",x); //输入车牌号

push(s,x);

i++;

printf("%d号车在停车场的位置是：%d\n",x,i);

break;

}

case 2:

{

scanf("%d",x); //输入车牌号

i=pop(s,x);

if(i==0)

break;

printf("该车离开后停车场剩余的车为：\n");

dispstack(s);

break;

}

case 3:

{

printf("停车场中的车辆为：\n");

dispstack(s);

break;

}

case 0:

{

exit(0);

break;

}

}

}while(y=3);

}