今天给各位分享c语言initqueue的知识，其中也会对贪吃蛇代码C语言进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
1、C语言数据结构 链队列2、哪位高手能帮我用C语言(不是C++哦)和数据结构做个停车场管理系统?包括实验报告!拜托啦！！！！！！3、用C语言编银行叫号系统4、求教c语言大神答疑5、C语言 魔王语言解释6、用c语言编一个小小的入列出列的程序
C语言数据结构 链队列
p=Q.front-next ;printf(“0000\n”);
Q.front-next 是NULL
e=p-data ; 所以，这里取data会出现程序异常！！！！！
printf(“1111\n”);//所以，这里就不会出现了！
哪位高手能帮我用C语言(不是C++哦)和数据结构做个停车场管理系统?包括实验报告!拜托啦！！！！！！
把扩展名改成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;
}
用C语言编银行叫号系统
#include “stdafx.h”
#include stdio.h
#include stdlib.h
#include time.h
#include string.h
#include conio.h
#define MAX_SIZE 500
struct tagCustom
{
int m_nID; // 客户的编号
int m_nProcessTime; // 需要处理业务的时间
int m_nArrivalTime; // 到达时间
int m_nDepartTime; // 离开时间
};
struct tagTeller
{
int m_nCustomNum; // 处理的客户数
int m_nAllServiceTime; // 所有服务时间
int m_nFinishServiceTime; // 柜台针对一个客户服务的结束时间
bool m_bBusy; // 柜台是否忙
int m_nCustomID; // 正在服务的客户的ID号
};
tagTeller g_aryTellers[MAX_SIZE];
int g_nTellerNum; // 柜台数量
// 用户到达数组（随机的，无序的）
tagCustom g_aryAllCustoms[MAX_SIZE];
int g_nCustomsNum;
int g_nWorkTime; // 经营时间
int g_nArrivalRange,g_nServiceRange;
// 用户队列
tagCustom g_CustomQueue[MAX_SIZE];
int g_nHeader,g_nTail;
// 队列的操作
void InitQueue()
{
g_nHeader = g_nTail = -1;
}
void AddToTail(tagCustom aCustom)
{
g_nTail++;
g_CustomQueue[g_nTail] = aCustom;
}
bool RemoveFromHeader(tagCustom* pCustom)
{
if(g_nHeader g_nTail)
{
g_nHeader++;
(*pCustom) = g_CustomQueue[g_nHeader];
return true;
}
return false;
}
// 功能：模拟用户的随机到来
void GenerateCustom()
{
tagCustom aCustom;
for(int nCounter = 0; nCounter g_nCustomsNum; nCounter++)
{
aCustom.m_nID = nCounter;
aCustom.m_nArrivalTime = rand() % g_nWorkTime ;
aCustom.m_nProcessTime = (rand() % g_nServiceRange + 1) * 6;
aCustom.m_nDepartTime = -1;
g_aryAllCustoms[nCounter] = aCustom;
}
}
void Init()
{
g_nTellerNum = 3;
g_nWorkTime = 200;
g_nCustomsNum = 30;
g_nArrivalRange = 18 ;
g_nServiceRange = 5 ;
srand((unsigned)time(NULL));
InitQueue();
GenerateCustom();
for(int nC = 0; nC g_nTellerNum; nC++)
{
g_aryTellers[nC].m_nAllServiceTime = 0;
g_aryTellers[nC].m_nCustomID = -1;
g_aryTellers[nC].m_bBusy = false;
g_aryTellers[nC].m_nFinishServiceTime = -1;
}
}
求教c语言大神答疑
SeqQueue EnQueue(SeqQueue q, QueueElementType x)
EnQueue(q,’a’);
EnQueue(q,’b’);
EnQueue(q,’c’);
这函数的声明与调用不符吧，EnQueue的返回值被丢弃了
EnQueue(q,’a’);
改为
q = EnQueue(q,’a’);
其他调用也要改。DeQueue、Length也有类似的问题。
C语言 魔王语言解释
#includestdio.h
#includestdlib.h
#includemalloc.h
#includestring.h
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef struct//定义栈结构体
{
char *base;
char *top;
int stacksize;
}SqStack;
typedef struct QNode//定义队结构体
{
char data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct//定义队头队尾指针 结构体
{
QueuePtr front;
QueuePtr rear;
}LinkQueue;
int InitStack(SqStack S);
int GetTop(SqStack S,char e);
int Push(SqStack S,char e);
int Pop(SqStack S,char e);
int InitQueue(LinkQueue Q);
int EnQueue(LinkQueue Q,char e);
int DeQueue(LinkQueue Q, char e);
int translate(char *p,int len,SqStack S,LinkQueue Q);
int main()
{
char str[100][100];
int i=0,d=0;
int len;
char *p;
SqStack S;
LinkQueue Q;
InitStack(S);
InitQueue(Q);
scanf(“%s”,str[0]);
while(str[i][0]!=’*’)
{
scanf(“%s”,str[++i]); //将N组数据放入二维数组中
d++;//d为数据组数N（不含***）
}
for(i=0;id;i++)
{
p=str[i];
len=strlen(str[i]);
translate(p,len,S,Q);
}
return 0;
}
int translate(char *p,int len,SqStack S,LinkQueue Q)
{
int D=0;
char e,q;
p=p+len-1;
while(Dlen){
while(*p!='(‘Dlen)//'(‘前的入栈
{
Push(S,*p);
–p;
D++;
}
if(D==len) break;
while(*(S.top-1)!=’)’)//栈顶元素不为’)’的出栈入队列
{
Pop(S,e);
EnQueue(Q,e);
}
if(*(S.top-1)==’)’D!=len) Pop(S,e);//将’)’出栈
while(Q.front!=Q.rear)//如果队列中有元素则将首元素出队列入栈
{
DeQueue(Q,q);//q为xita
Push(S,q);
break;
}
while(Q.front!=Q.rearD!=len)//出队列入栈
{
DeQueue(Q,e);
Push(S,e);
Push(S,q);
}
if(*p=='(‘)
p=p-1;
}
while(S.top!=S.base)
{
Pop(S,e);
if(e==’B’)
printf(“tsaedsae”);
else if(e==’A’)
printf(“sae”);
else if(e==’\0′) continue;
else
printf(“%c”,e);
}
printf(“\n”);
return 0;
}
int InitStack(SqStack S)
{
S.base=(char*)malloc(STACK_INIT_SIZE*sizeof(char));
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}
int GetTop(SqStack S,char e) //获取栈顶元素并用e返回
{
if(S.top = S.base) return ERROR;
e=*(S.top-1);
return OK;
}
int Push(SqStack S,char e) //元素e入栈
{
if(S.top-S.base=S.stacksize)
{
S.base = (char*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(char));
if(!S.base) exit(OVERFLOW);
S.top = S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}
int Pop(SqStack S,char e) //出栈将栈顶元素赋值于e
{
if(S.top==S.base) return ERROR;
e=*–S.top;
return OK;
}
int InitQueue(LinkQueue Q) //建立一个空队
{
Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
if(!Q.front) exit(OVERFLOW);
Q.front-next=NULL;
return OK;
}
int EnQueue(LinkQueue Q,char e) //插入元素e为新的队尾元素
{
QueuePtr p;
p = (QueuePtr)malloc(sizeof(QNode));
if(!p) exit(OVERFLOW);
p-data = e;
p-next = NULL;
Q.rear-next = p;
Q.rear = p;
return OK;
}
int DeQueue(LinkQueue Q, char e) //删除Q的队头元素并用e返回
{
QueuePtr p;
if(Q.front==Q.rear) exit(OVERFLOW);
p=Q.front-next;
e=p-data;
Q.front-next = p-next;
if(Q.rear==p)
Q.rear=Q.front;
free(p);
return OK;
}
用c语言编一个小小的入列出列的程序
你主要是想实现队列功能吧，我给你编了一个队列，具体的出列进列可随意在主函数中操作#include stdio.h
#include malloc.h
typedef struct QNode
{
char data;
struct QNode *next;
int Queusize;
}
QNode,*QueuePtr;//定义队列结点类型
typedef struct
{
QueuePtr front;
QueuePtr rear;
}
LinkQueue;//队列的类型
void InitQueue(LinkQueue *Q)//创建队列
{
Q-front=Q-rear=(QueuePtr)malloc(sizeof(QNode));
Q-front-next=NULL;
}
void EnQueue(LinkQueue *Q,char e)//将元素插入队列
{
QueuePtr p;
p=(QueuePtr)malloc(sizeof(QNode));
p-data=e;
p-next=NULL;
Q-rear-next=p;
Q-rear=p;
}
char DeQueue(LinkQueue *Q)//将元素出列且返回元素的位置
{
char e;
QueuePtr p;
p=Q-front-next;
e=p-data;
Q-front-next=p-next;
if(Q-rear==p)
Q-rear=Q-front;
free(p);
return (e);
}
int QueueEmpty(LinkQueue *Q)//判断队列是否为空
{
if(Q-front==Q-rear )
return 1;
else
return 0;
}void main()
{
LinkQueue Q;
InitQueue(Q);
EnQueue(Q,’1′);//字符1入队列
EnQueue(Q,’2′);
EnQueue(Q,’3′);
EnQueue(Q,’4′);
EnQueue(Q,’5′);
DeQueue(Q);//最先一个元素出列也就是1出列
DeQueue(Q);
while(!QueueEmpty(Q))
{
printf(“%c “,DeQueue(Q));//最后剩下的元素依次出列
}
}
c语言initqueue的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于贪吃蛇代码C语言、c语言initqueue的信息别忘了在本站进行查找喔。
微信扫一扫 
支付宝扫一扫 
