停車場管理數據結構課程設計

❹ 數據結構課程設計 停車場管理問題

粗略改了，不過內存什麼的自己再弄弄吧。

//頭文件
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>

//函數返回狀態代碼
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define INFEASIBLE -1
#define OVERFLOW -2

#define SIZE 5//停車場位置數
typedef int Status;

//棧，模擬停車場
typedef struct Car1{//車
int number;//汽車車號
int ar_time;//汽車到達時間
}CarNode;

typedef struct{//停車場
CarNode *base;//停車場的堆棧底
CarNode *top;//停車場的堆棧頂
int stacksize;
}Park;

//隊列，模擬便道
typedef struct Car2{//車
int number;//汽車車號
int ar_time;//汽車到達時間
struct Car2 *next;
}*CarPtr;

typedef struct{//便道
CarPtr front;//便道的隊列的對頭
CarPtr rear;//便道的隊列的隊尾
int length;
}Shortcut;

Status InitStack(Park &P){//初始化停車場
P.base=(CarNode*)malloc(SIZE*sizeof(Car1));
if(!P.base) exit(OVERFLOW);
P.top=P.base;
P.stacksize=0;
return OK;
}

Status Push(Park &P,CarNode e){//車進入停車場
*P.top++=e;
++P.stacksize;
return OK;
}

Status Pop(Park &P,CarNode &e){//車離開停車場
if(P.top==P.base)
printf("停車場為空。");
else
{
e=*--P.top;
--P.stacksize;
}
return OK;
}

Status InitQueue(Shortcut &S){//初始化便道
S.front=S.rear=(CarPtr)malloc(sizeof(Car2));
if(!S.front||!S.rear) exit(OVERFLOW);
S.front->next=NULL;
S.length=0;
return OK;
}

Status EnQueue(Shortcut &S,int number,int ar_time){//車進入便道
CarPtr p;
p=(CarPtr)malloc(sizeof(Car2));
if(!p) exit(OVERFLOW);
p->number=number;
p->ar_time=ar_time;
p->next=NULL;
S.rear->next=p;
S.rear=p;
++S.length;
return OK;
}

Status DeQueue(Shortcut &S,CarPtr &w){//車離開便道
if(S.length == 0)
printf("通道為空。");
else
{
w = S.front->next;
S.front->next=S.front->next->next;
--S.length;
}
return OK;
}

Status Arrival(Park &P,Shortcut &S){//對進站車輛的處理
int number,ar_time;
printf("請輸入車牌號：");
scanf("%d",&number);
printf("進場的時刻:");
scanf("%d",&ar_time);
if(P.stacksize<SIZE)
{
CarNode c;
c.number=number;
c.ar_time=ar_time;
Push(P,c);
printf("該車應停在第%d號車道。\n",P.stacksize);
}
else
{
EnQueue(S,number,ar_time);
printf("停車場已滿，請暫時停在便道的第%d個位置。\n",S.length);
}
return OK;
}

Status Leave(Park &P,Park &P1,Shortcut &S){//對離站車輛的處理
int number,le_time,flag=1,money,ar_time;
printf("請輸入車牌號：");
scanf("%d",&number);
printf("出場的時刻:");
scanf("%d",&le_time);
CarNode e,m;
CarPtr w;
while(P.stacksize)
{
Pop(P,e);
if(e.number==number)
{
flag=0;
money=(le_time-e.ar_time)*2;
ar_time=e.ar_time;
break;
}

Push(P1,e);
}

while(P1.stacksize)
{
Pop(P1,e);
Push(P,e);
}

// 車從停車場中出
if (flag == 0)
{
if(S.length!=0)
{
DeQueue(S,w);
m.ar_time=le_time;
m.number=w->number;
Push(P,m);
free(w);
printf("車牌號為%d的車已由便道進入停車場\n",m.number);
}

printf("停車費為%d, 佔用車位數為%d\n",money,P.stacksize);
}
else
{
printf("停車場不存在牌號為%d的車\n", number);
}

return OK;
}

int main()
{
int m=1;
char flag;//選項
Park P,Q;
Shortcut S;
InitStack(P);
InitStack(Q);
InitQueue(S);

while(m)
{
printf("\n 停車場管理程序 \n");
printf("===============================================\n");
printf("** A 汽車進車場 **\n");
printf("** **\n");
printf("** D 汽車出車場 **\n");
printf("** **\n");
printf("** E 退出程序 **\n");
printf("===============================================\n");
printf("請選擇(A,D,E): ");
scanf("%c",&flag);
switch(flag)
{
case 'A':
case 'a':
Arrival(P,S);break; //車進入停車場
case 'D':
case 'd':
Leave(P,Q,S);break; //車離開停車場
case 'E':
case 'e':
m=0;
break;
default:
printf("Input error!\n");
break;
}
while (flag != '\n')
scanf("%c",&flag);
}
}

❺ 停車場管理 數據結構

真巧，我們剛做完這個題目！發給你看看：一定要採納哦！嘿嘿
#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("\t\t===========歡迎你進入停車場管理系統===========\n");
printf("\t\t 徐沙利 20074470149\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( "徐沙利 - Build201006\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;
}

❻ 數據結構課程設計--用棧建立一個停車場管理系統

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define MAX 20
#define price 0.05

typedef struct time{
int hour;
int min;
}Time;

typedef struct node{
char num[10];
Time reach;
Time leave;
}CarNode;

typedef struct NODE{
CarNode *stack[MAX+1];
int top;
}SeqStackCar;

typedef struct car{
CarNode *data;
struct car *next;
}QueueNode;

typedef struct Node{
QueueNode *head;
QueueNode *rear;
}LinkQueueCar;

void InitStack(SeqStackCar *);
int InitQueue(LinkQueueCar *);
int Arrival(SeqStackCar *,LinkQueueCar *);
void Leave(SeqStackCar *,SeqStackCar *,LinkQueueCar *);
void List(SeqStackCar,LinkQueueCar);

void main()
{
SeqStackCar Enter,Temp;
LinkQueueCar Wait;
int ch;
InitStack(&Enter);
InitStack(&Temp);
InitQueue(&Wait);
while(1)
{
printf("\n1. 車輛到達登記");
printf(" 2. 車輛離開登記");
printf(" 3. 車輛列表顯示");
printf(" 4. 退出系統\n");
while(1)
{
scanf("%d",&ch);
if(ch>=1&&ch<=4)break;
else printf("\n請選擇： 1~4.");
}
switch(ch)
{
case 1:Arrival(&Enter,&Wait);break;
case 2:Leave(&Enter,&Temp,&Wait);break;
case 3:List(Enter,Wait);break;
case 4:exit(0);
default: break;
}
}
}

void InitStack(SeqStackCar *s){

int i;
s->top=0;
for(i=0;i<=MAX;i++)
s->stack[s->top]=NULL;
}
int InitQueue(LinkQueueCar *Q){

Q->head=(QueueNode *)malloc(sizeof(QueueNode));
if(Q->head!=NULL)
{
Q->head->next=NULL;
Q->rear=Q->head;
return(1);
}
else return(-1);
}
void PRINT(CarNode *p,int room){

int A1,A2,B1,B2;
printf("\n車輛離開的時間:");
scanf("%d:%d",&(p->leave.hour),&(p->leave.min));
printf("\n離開車輛的車牌號為:");
puts(p->num);
printf("\n其到達時間為: %d:%d",p->reach.hour,p->reach.min);
printf("離開時間為: %d:%d",p->leave.hour,p->leave.min);
A1=p->reach.hour;
A2=p->reach.min;
B1=p->leave.hour;
B2=p->leave.min;
printf("\n應交費用為: %2.1f元",((B1-A1)*60+(B2-A2))*price);
free(p);
}
int Arrival(SeqStackCar *Enter,LinkQueueCar *W){

CarNode *p;
QueueNode *t;
p=(CarNode *)malloc(sizeof(CarNode));
flushall();
printf("\n請輸入車牌號(例:豫B1234):");
gets(p->num);
if(Enter->top<MAX)
{
Enter->top++;
printf("\n車輛在車場第%d位置.",Enter->top);
printf("\n車輛到達時間:");
scanf("%d:%d",&(p->reach.hour),&(p->reach.min));
Enter->stack[Enter->top]=p;
return(1);
}
else
{
printf("\n該車須在便道等待!有車位時進入車場");
t=(QueueNode *)malloc(sizeof(QueueNode));
t->data=p;
t->next=NULL;
W->rear->next=t;
W->rear=t;
return(1);
}
}
void Leave(SeqStackCar *Enter,SeqStackCar *Temp,LinkQueueCar *W)
{
int room;
CarNode *p,*t;
QueueNode *q;

if(Enter->top>0)
{
while(1)
{
printf("\n請輸入車在車場的位置/1--%d/：",Enter->top);
scanf("%d",&room);
if(room>=1&&room<=Enter->top) break;
}
while(Enter->top>room)
{
Temp->top++;
Temp->stack[Temp->top]=Enter->stack[Enter->top];
Enter->stack[Enter->top]=NULL;
Enter->top--;
}
p=Enter->stack[Enter->top];
Enter->stack[Enter->top]=NULL;
Enter->top--;
while(Temp->top>=1)
{
Enter->top++;
Enter->stack[Enter->top]=Temp->stack[Temp->top];
Temp->stack[Temp->top]=NULL;
Temp->top--;
}
PRINT(p,room);

if((W->head!=W->rear)&&Enter->top<MAX)
{
q=W->head->next;
t=q->data;
Enter->top++;
printf("\n便道的%s號車進入車場第%d位置.",t->num,Enter->top);
printf("\n請輸入%s號車進入車場的時間:");
scanf("%d:%d",&(t->reach.hour),&(t->reach.min));
W->head->next=q->next;
if(q==W->rear) W->rear=W->head;
Enter->stack[Enter->top]=t;
free(q);
}
else printf("\n便道里沒有車.\n");
}
else printf("\n車場里沒有車.");
}
void List1(SeqStackCar *S)
{
int i;
if(S->top>0)
{
printf("\n車場:");
printf("\n 位置到達時間 車牌號\n");
for(i=1;i<=S->top;i++)
{
printf(" %d ",i);
printf(" %d:%d ",S->stack[i]->reach.hour,S->stack[i]->reach.min);
puts(S->stack[i]->num);
}
}
else printf("\n車場里沒有車");
}
void List2(LinkQueueCar *W)
{
QueueNode *p;
p=W->head->next;
if(W->head!=W->rear)
{
printf("\n等待車輛的號碼為:");
while(p!=NULL)
{
puts(p->data->num);
p=p->next;
}
}
else printf("\n便道里沒有車.");
}
void List(SeqStackCar S,LinkQueueCar W)
{
int flag,tag;
flag=1;
while(flag)
{
printf("\n請選擇 1|2|3:");
printf("\n1.車場列表\n2.便道列表\n3.返回主菜單\n");
while(1)
{
scanf("%d",&tag);
if(tag>=1||tag<=3) break;
else printf("\n請選擇 1~3:");
}
switch(tag)
{
case 1:List1(&S);break;
case 2:List2(&W);break;
case 3:flag=0;break;
default: break;
}
}
}

❼ 數據結構 停車場管理 JAVA（急！！！）

import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Stack;
import java.util.Vector;
import java.util.regex.MatchResult;

public class Test {
private CarStop carStop = new CarStop(3);
private CarTunnel tunnel = new CarTunnel();
public void test(){
//存放車輛信息，因為不是順序輸入的，所以放到Map中
HashMap<Integer, Car> carMap = new HashMap<Integer, Car>();
//最早進入車庫的時間和最晚出車庫的時間
int startTime, endTime;

startTime = Integer.MAX_VALUE;
endTime = Integer.MIN_VALUE;

Scanner scanner = new Scanner(System.in);
//("A"或者"D"或者"E", int, int)
while(scanner.hasNext("\\((A|D|E),(\\d+),(\\d+)\\)")){
scanner.next("\\((A|D|E),(\\d+),(\\d+)\\)");
MatchResult r = scanner.match();
Car car;
//如果輸入A
if (r.group(1).equalsIgnoreCase("A")){
// 該車已經記錄過
if (carMap.keySet().contains(Integer.parseInt(r.group(2)))){
// 取出來設置到達時間
car = carMap.get(Integer.parseInt(r.group(2)));
car.arrive = Integer.parseInt(r.group(3));
}else{
// 否則就記錄該車
car = new Car(Integer.parseInt(r.group(2)), Integer.parseInt(r.group(3)));
carMap.put(car.no, car);
}
if (car.arrive < startTime) startTime = car.arrive;
if (car.leave > endTime) endTime = car.leave;
// 出庫時間和到達時間同樣處理
}else if (r.group(1).equalsIgnoreCase("D")){
if (carMap.keySet().contains(Integer.parseInt(r.group(2)))){
car = carMap.get(Integer.parseInt(r.group(2)));
car.leave = Integer.parseInt(r.group(3));
}else{
car = new Car(Integer.parseInt(r.group(2)), 0, Integer.parseInt(r.group(3)));
carMap.put(car.no, car);
}
if (car.arrive < startTime) startTime = car.arrive;
if (car.leave > endTime) endTime = car.leave;
}else if (r.group(1).equalsIgnoreCase("E")){
break;
}
}

// 把記錄過的車做成數組並且排序
Car[] cars = new Car[carMap.size()];
cars = carMap.values().toArray(cars);
Arrays.sort(cars, new Comparator<Car>(){
// 排序順序是到達時間>出庫時間>車牌
public int compare(Car c1, Car c2) {
if (c1.arrive!=c2.arrive) return c1.arrive - c2.arrive;
if (c1.leave!=c2.leave) return c1.leave - c2.leave;
return c1.no - c2.no;
}

});

for (int time=startTime; time<=endTime; time++){
System.out.println("TIME:" + time);
for (int k=0;k<cars.length;k++){
Car car = cars[k];
//如果有車在沒有進入停車場的時候就已經到了出庫時間
if (car.leave == time && carStop.isFull() && !carStop.contains(car)){
for (int i=tunnel.size()-1;i>=0;i--){
Car c = tunnel.get(i);
if (c.equals(car)){
for (int j=i+1;j<tunnel.size();j++){
System.out.println(car + "為" + car + "讓路，重新進入等待區");
}
tunnel.remove(car);
System.out.println(car + "沒進入過停車場就離開了");
}else{
System.out.println(car + "為" + car + "讓路");
}
}
}else{
// 如果有車子現在到達
if (car.arrive == time){
// 停車場不滿
if (!carStop.isFull()) {
// 進入停車場
carStop.push(car);
// 開始計費
car.chargeStart = time;
System.out.println(car + "進入停車場並且開始計費");
}else{
// 停車場滿，等待
System.out.println(car + "到達，在等待區等待");
tunnel.push(car);
}
}
}
}
//deal with cars in stop
//the case cars leave at same time is not included
// 按照後進先出的順序看有沒有車要離開
for (int k=carStop.size() - 1; k>=0; k--){
Car car = carStop.elementAt(k);
//准備離開
if (car.leave == time){
Car otherCar;
// 所有在他後面進來的車准備讓路
while ((otherCar = carStop.pop())!=car){
// 進入等待區的最前面
tunnel.unshift(otherCar);
System.out.println(otherCar + "准備為" + car + "讓路");
}

for (int m=tunnel.size()-1;m>=0;m--){
System.out.println(tunnel.elementAt(m) + "為" + car + "讓路");
}
System.out.println(otherCar + "離開，停車時間:" + (otherCar.leave - otherCar.chargeStart));
for (int m=0; m<tunnel.size(); m++){
System.out.println(tunnel.elementAt(m) + "讓路完畢，重新進入等待區");
}
Car waitingCar;
//停車場有空位，等待序列最前面的車入庫
while ( !carStop.isFull() && (waitingCar = tunnel.shift())!=null ){
carStop.push(waitingCar);
// 停車計時開始
if (waitingCar.chargeStart == -1) {
System.out.println(waitingCar + "停車計時時間改為:" + time);
waitingCar.chargeStart = time;
}
System.out.println(waitingCar + "進入停車場");
}
}
}

}

}
public static void main(String[] args){
new Test().test();
}
}

@SuppressWarnings("serial")
class CarTunnel extends Vector<Car>{

public CarTunnel(){
super();
}

public Car shift(){
if (size() == 0) return null;
return remove(0);
}

public void unshift(Car car){
super.add(0, car);
}

public void push(Car car){
super.add(car);
}

public Car pop(){
if (size() == 0) return null;
return remove(size()-1);
}

}
@SuppressWarnings("serial")
class CarStop extends Stack<Car>{

private int size;

public CarStop(int size){
this.size = size;
}

public boolean isFull(){
return size() == size;
}

public Car pop(){
return super.pop();
}

public Car push(Car car){
if (size() <= size){
return super.push(car);
}else{
return null;
}
}
}

class Car{
public int no;
public int arrive;
public int leave;

public int chargeStart = -1;

public Car(int no, int timeIn, int timeOut){
this.no = no;
this.arrive = timeIn;
this.leave = timeOut;
}

public Car(int no, int timeIn){
this(no, timeIn, -1);
}

public String toString(){
return String.format("Car(%d)", no);
}
}

結果：
(A,6,31)
(A,5,30)
(A,4,20)
(A,3,16)
(A,2,15)
(A,1,10)
(D,1,50)
(D,2,30)
(D,3,31)
(D,4,25)
(D,5,32)
(D,6,40)
(E,0,0)
TIME:10
Car(1)進入停車場並且開始計費
TIME:11
TIME:12
TIME:13
TIME:14
TIME:15
Car(2)進入停車場並且開始計費
TIME:16
Car(3)進入停車場並且開始計費
TIME:17
TIME:18
TIME:19
TIME:20
Car(4)到達，在等待區等待
TIME:21
TIME:22
TIME:23
TIME:24
TIME:25
Car(4)沒進入過停車場就離開了
TIME:26
TIME:27
TIME:28
TIME:29
TIME:30
Car(5)到達，在等待區等待
Car(3)准備為Car(2)讓路
Car(5)為Car(2)讓路
Car(3)為Car(2)讓路
Car(2)離開，停車時間:15
Car(3)讓路完畢，重新進入等待區
Car(5)讓路完畢，重新進入等待區
Car(3)進入停車場
Car(5)停車計時時間改為:30
Car(5)進入停車場
TIME:31
Car(6)到達，在等待區等待
Car(5)准備為Car(3)讓路
Car(6)為Car(3)讓路
Car(5)為Car(3)讓路
Car(3)離開，停車時間:15
Car(5)讓路完畢，重新進入等待區
Car(6)讓路完畢，重新進入等待區
Car(5)進入停車場
Car(6)停車計時時間改為:31
Car(6)進入停車場
TIME:32
Car(6)准備為Car(5)讓路
Car(6)為Car(5)讓路
Car(5)離開，停車時間:2
Car(6)讓路完畢，重新進入等待區
Car(6)進入停車場
TIME:33
TIME:34
TIME:35
TIME:36
TIME:37
TIME:38
TIME:39
TIME:40
Car(6)離開，停車時間:9
TIME:41
TIME:42
TIME:43
TIME:44
TIME:45
TIME:46
TIME:47
TIME:48
TIME:49
TIME:50
Car(1)離開，停車時間:40

❽ 急求數據結構 停車場管理設計 C語言

5分 你太扣了

❾ C++ 停車場管理 數據結構 課程設計

你好朋友，試下這個！希望可以幫到你

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX 2 /*車庫容量*/
typedef struct node
{char num[10];
}CarNode;/*車輛信息結點*/
typedef struct NODE{
CarNode *stack[MAX+1];
int top;
}SeqStackCar; /*模擬車站*/
typedef struct car{
CarNode *data;
struct car *next;
}QueueNode;
typedef struct Node{
QueueNode *head;
QueueNode *rear;
}LinkQueueCar; /*模擬通道*/
void InitStack(SeqStackCar *); /*初始化棧*/
int InitQueue(LinkQueueCar *); /*初始化便道*/
int Arrival(SeqStackCar *,LinkQueueCar *); /*車輛到達*/
void Leave(SeqStackCar *,SeqStackCar *,LinkQueueCar *); /*車輛離開*/
void List(SeqStackCar,LinkQueueCar); /*顯示存車信息*/
void main()
{SeqStackCar Enter,Temp;
LinkQueueCar Wait;
int ch;
InitStack(&Enter); /*初始化車站*/
InitStack(&Temp); /*初始化讓路的臨時棧*/
InitQueue(&Wait); /*初始化通道*/
printf("\n\n\n 題 目：模擬停車場管理問題\n\n");
printf("\n\n\n\n\n-----------按任意鍵繼續---------------");
getch();
clrscr();
while(1)
{ printf("\n1. 車輛到達");
printf(" 2. 車輛離開");
printf(" 3. 列表顯示");
printf(" 4. 退出系統\n");
while(1)
{scanf("%d",&ch);
if(ch>=1&&ch<=4)break;
else printf("\n請選擇： 1|2|3|4.");
}
switch(ch)
{ case 1:Arrival(&Enter,&Wait);break; /*車輛到達*/
case 2:Leave(&Enter,&Temp,&Wait);break; /*車輛離開*/
case 3:List(Enter,Wait);break; /*列表列印信息*/
case 4:exit(0); /*退出主程序*/
default: break;
}}}
void InitStack(SeqStackCar *s) /*初始化棧*/
{ int i;
s->top=0;
for(i=0;i<=MAX;i++)
s->stack[s->top]=NULL;}
int InitQueue(LinkQueueCar *Q) /*初始化便道*/
{Q->head=(QueueNode *)malloc(sizeof(QueueNode));
if(Q->head!=NULL)
{Q->head->next=NULL;
Q->rear=Q->head;
return(1);}
else return(-1);}
void PRINT(CarNode *p) /*列印出站車的信息*/
{
printf("\n離開車輛的車牌號為:");
puts(p->num);
}
int Arrival(SeqStackCar *Enter,LinkQueueCar *W) /*車輛到達*/
{ CarNode *p;
QueueNode *t;
p=(CarNode *)malloc(sizeof(CarNode));
flushall();
printf("\n請輸入車牌號(例:陝A1234):");
gets(p->num);
if(Enter->top<MAX) /*車場未滿，車進車場*/
{Enter->top++;
printf("\n車輛在車場第%d位置.",Enter->top);
Enter->stack[Enter->top]=p;
return(1);}
else /*車場已滿，車進便道*/
{ printf("\n該車須在便道等待!");
t=(QueueNode *)malloc(sizeof(QueueNode));
t->data=p;
t->next=NULL;
W->rear->next=t;
W->rear=t;
return(1); }}
void Leave(SeqStackCar *Enter,SeqStackCar *Temp,LinkQueueCar *W)/*車輛離開*/
{
int i, room;
CarNode *p,*t;
QueueNode *q;
/*判斷車場內是否有車*/
if(Enter->top>0) /*有車*/
{ while(1) /*輸入離開車輛的信息*/
{printf("\n請輸入車在車場的位置/1--%d/：",Enter->top);
scanf("%d",&room);
if(room>=1&&room<=Enter->top) break;}
while(Enter->top>room) /*車輛離開*/
{Temp->top++;
Temp->stack[Temp->top]=Enter->stack[Enter->top];
Enter->stack[Enter->top]=NULL;
Enter->top--;
}
p=Enter->stack[Enter->top];
Enter->stack[Enter->top]=NULL;
Enter->top--;
while(Temp->top>=1)
{Enter->top++;
Enter->stack[Enter->top]=Temp->stack[Temp->top];
Temp->stack[Temp->top]=NULL;
Temp->top--;}
PRINT(p);
/*判斷通道上是否有車及車站是否已滿*/
if((W->head!=W->rear)&&Enter->top<MAX) /*便道的車輛進入車場*/
{ q=W->head->next;
t=q->data;
Enter->top++;
printf("\n便道的%s號車進入車場第%d位置.",t->num,Enter->top);
W->head->next=q->next;
if(q==W->rear) W->rear=W->head;
Enter->stack[Enter->top]=t;
free(q);}
else printf("\n便道里沒有車.\n");}
else printf("\n車場里沒有車."); /*沒車*/ }
void List1(SeqStackCar *S) /*列表顯示車場信息*/
{int i;
if(S->top>0) /*判斷車站內是否有車*/
{printf("\n車場:");
printf("\n 位置 車牌號\n");
for(i=1;i<=S->top;i++)
{printf(" %d ",i);
puts(S->stack[i]->num);}}
else printf("\n車場里沒有車");}
void List2(LinkQueueCar *W) /*列表顯示便道信息*/
{ QueueNode *p;
p=W->head->next;
if(W->head!=W->rear) /*判斷通道上是否有車*/
{printf("\n等待車輛的號碼為:\n");
while(p!=NULL)
{puts(p->data->num);
p=p->next;}}
else printf("\n便道里沒有車."); }
void List(SeqStackCar S,LinkQueueCar W)
{int flag,tag;
flag=1;
while(flag)
{printf("\n請選擇 1|2|3:");
printf("\n1.車場\n2.便道\n3.返回\n");
while(1)
{ scanf("%d",&tag);
if(tag>=1||tag<=3) break;
else printf("\n請選擇 1|2|3:");
}switch(tag)
{case 1:List1(&S);break; /*列表顯示車場信息*/
case 2:List2(&W);break; /*列表顯示便道信息*/
case 3:flag=0;break;
default: break; }}}

❿ [數據結構] 用隊列或棧實現一個簡單停車場管理，怎麼設計啊

資料庫是肯定要有的
可能要做一些表
和索引
具體的情況
不是一兩句就能說清楚的