void merge(int *p, int low, int middle, int high)
{
int i;
queue_t *q1 = &queue1;
queue_t *q2 = &queue2;
queue_init(q1);
queue_init(q2);
for (i = low; i <= middle; i++)
en_queue(q1, p[i]);
for (i = middle + 1; i <= high; i++)
en_queue(q2, p[i]);
i = low;
while (!(empty_queue(q1) || empty_queue(q2))) {
if (head_queue(q1) > head_queue(q2))
p[low++] = de_queue(q1);
else
p[low++] = de_queue(q2);
}
while (!(empty_queue(q1)))
p[low++] = de_queue(q1);
while (!(empty_queue(q2)))
p[low++] = de_queue(q2);
}
/*
用两个队列模拟出栈操作
*/
bool pop(PQUEUE pS1,PQUEUE pS2,int *pData)
{
if(is_empty(pS1) && is_empty(pS2))
return false;
int DelData;
if(!is_empty(pS2))
{
int len = length(pS2);
while(len-- > 1)
{
de_queue(pS2,&DelData);
en_queue(pS1,DelData);
}
//将队列的最后一个元素出队，作为出栈元素
de_queue(pS2,pData);
return true;
}
if(!is_empty(pS1))
{
int len = length(pS1);
while(len-- > 1)
{
de_queue(pS1,&DelData);
en_queue(pS2,DelData);
}
//将队列的最后一个元素出队，作为出栈元素
de_queue(pS1,pData);
return true;
}
}
int main()
{
int data_de = 0; //用来保存出队的元素值
//创建队列并进行入队测试
PQUEUE pS = create_queue();
en_queue(pS,2);
en_queue(pS,4);
en_queue(pS,6);
traverse_queue(pS);
//出队测试
if(de_queue(pS,&data_de))
printf("delete succeed,the deleted data is: %d\n",data_de);
else
printf("queue is empty! delete falied!\n");
traverse_queue(pS);
//销毁队列测试
destroy_queue(pS);
printf("queue destroyed!\n");
traverse_queue(pS);
return 0;
}
static void merge(int s[], int low, int middle, int high) {
int i;
queue buffer1, buffer2; /* buffers to hold elements for merging*/
init_queue(&buffer1);
init_queue(&buffer2);
for (i = low; i <= middle; i++)
en_queue(&buffer1, &s[i], sizeof (int));
for (i = middle + 1; i <= high; i++)
en_queue(&buffer2, &s[i], sizeof (int));
i = low;
while (!(empty_queue(&buffer1) || empty_queue(&buffer2))) {
if (*(int*) head_queue(&buffer1) <= *(int*) head_queue(&buffer2))
s[i++] = deq_buffer(&buffer1);
else
s[i++] = deq_buffer(&buffer2);
}
while (!empty_queue(&buffer1))
s[i++] = deq_buffer(&buffer1);
while (!empty_queue(&buffer2))
s[i++] = deq_buffer(&buffer2);
clear_queue(&buffer1);
clear_queue(&buffer2);
}
/*
用两个队列模拟入栈操作
*/
void push(PQUEUE pS1,PQUEUE pS2,int val)
{
if(is_empty(pS2))
en_queue(pS1, val);
else
en_queue(pS2, val);
}
int main(void)
{
Queue q = {0};
init(&q, kQueue_len);
en_queue(&q, 1);
en_queue(&q, 2);
en_queue(&q, 3);
en_queue(&q, 4);
en_queue(&q, 5);
en_queue(&q, 6);
en_queue(&q, 7);
en_queue(&q, 8);
traverse_queue(&q);
int pVal;
if (out_queue(&q, &pVal)) {
printf("出队成功，队列出队元素是%d\n", pVal);
} else {
printf("出队失败！\n");
}
traverse_queue(&q);
return 0;
}
// event router
static Event* event_router(Customer* c,int component_id)
{
Event *event = NULL;
switch(component_list[component_id]->type)
{
case 'Q':
{
Queue *queue = C2Q(component_list[component_id]);
if(is_queue_empty(queue))
{
event = (Event*)malloc(sizeof(Event));
event->component_id = component_id;
event->event_type = DEPARTURE;
event->serve_time = randexp(queue->P);
event->timestamp = now_time+ event->serve_time;
event->next = NULL;
}else
event = NULL;
en_queue(queue,c);
}break;
case 'F':
{
Fork *fork = C2F(component_list[component_id]);
event = event_router(c,simulation_fork(fork));
}break;
case 'E':
{
Exit *_exit = C2E(component_list[component_id]);
simulation_exit(_exit,c);
event = NULL;
}break;
}
return event;
}
void inserer(t_valeurMot mot) {
/*Insère un élément dans la liste, en préservant l'ordre croissant des valeurs de la liste*/
int valeur, valeur_actuelle;
valeur = mot.score;
if(liste_vide()) {
ajout_droit(mot);
} else {
en_tete();
valeur_elt(&valeur_actuelle);
while(!hors_liste() && valeur_actuelle < valeur) {
suivant();
valeur_elt(&valeur_actuelle);
}
if(hors_liste()) {
en_queue();
ajout_droit(mot);
} else {
ajout_gauche(mot);
}
}
}
void do_keyboard()
{
u8 scan_code = io_inb(0x60); /* 读取扫描码 */
if (!is_queue_full(&kb_queue)) /* 若队列未满则入队，否则放弃该扫描码 */
{
en_queue(&kb_queue, scan_code);
}
io_outb(0x20, 0x20);
}
syscall future_set(future *f, int *i) {
irqmask mask;
mask = disable();
if(f == NULL){
restore(mask);
return SYSERR;
}
if(f->flag == FUTURE_EXCLUSIVE) {
if(f->state == FUTURE_WAITING) {
f->value = *i;
f->state = FUTURE_VALID;
resume(f->tid);
restore(mask);
return OK;
}
f->value = *i;
f->state = FUTURE_VALID;
restore(mask);
return OK;
}
if(f->flag == FUTURE_SHARED) {
if(f->state == FUTURE_VALID) {
printf("Producer already set, Error!\n");
restore(mask);
return SYSERR;
}
f->state = FUTURE_VALID;
f->value = *i;
if(!emp_queue(&(f->get_queue))){
peek_queue(&(f->get_queue));
resume(del_queue(&(f->get_queue)));
}
restore(mask);
return OK;
}
if(f->flag == FUTURE_QUEUE){
if(emp_queue(&(f->get_queue))) {
en_queue(&(f->set_queue), gettid());
restore(mask);
return SYSERR;
}
else {
f->state = FUTURE_VALID;
f->value = *i;
f->tid = peek_queue(&(f->get_queue));
resume(del_queue(&(f->get_queue)));
restore(mask);
return OK;
}
return OK;
}
restore(mask);
return SYSERR;
}
void INTERRUPT FAR serial(
void)
{ /* interrupt handler */
int temp;
disable();
while (1) {
comm_status.intrupt = inp(ComBase + INT_ID);
comm_status.intrupt &= 0x0f;
switch (comm_status.intrupt) {
case 0x00: /* modem interrupt */
comm_status.modem = inp(ComBase + MODEM_STATUS);
break;
case 0x02: /* xmit interrupt */
if (queue_empty(Serial_Out_Queue))
outp(ComBase + INT_EN, RX_INT | ERR_INT | RS_INT);
else {
temp = de_queue(Serial_Out_Queue);
if (-1 != temp)
outp(ComBase + XMIT, temp);
}
break;
case 0x04: /* receive interrupt */
en_queue(Serial_In_Queue, (char) inp(ComBase + REC));
break;
case 0x06: /* line interrupt */
comm_status.line = inp(ComBase + LINE_STATUS);
(void) inp(ComBase + REC);
en_queue(Serial_In_Queue, '!');
break;
default: /* No Mo` Left */
comm_status.modem = inp(ComBase + MODEM_STATUS);
outp(0x20, 0x20);
enable();
return;
} /* switch */
} /* while */
}
//*****************************************
// main函数
//*****************************************
void main()
{
QUEUE queue;
init(&queue);
en_queue(&queue,1);
en_queue(&queue,2);
en_queue(&queue,3);
en_queue(&queue,4);
en_queue(&queue,5);
traverse(&queue);
int v;
out_queue(&queue,&v);
traverse(&queue);
out_queue(&queue,&v);
traverse(&queue);
out_queue(&queue,&v);
traverse(&queue);
out_queue(&queue,&v);
traverse(&queue);
}
int main(int argc, char *argv[])
{
QUEUE Q;
int val;
init_queue(&Q);
en_queue(&Q,1);
en_queue(&Q,2);
en_queue(&Q,3);
en_queue(&Q,4);
en_queue(&Q,5);
traverse_queue(&Q);
if(del_queue(&Q,&val)) printf("出队成功。出队元素为：%d\n",val);
else printf("抱歉！出队失败。\n");
traverse_queue(&Q);
return 0;
}
void vider_liste()
{
if(!liste_vide()){
en_queue();//on commence en fin de liste car on utilise oter_elt() qui se positionne sur le predecesseur
/*on enleve les elements un par un jusqu'à ce que la liste soit vide*/
while(!hors_liste()){
oter_elt();
}
}
}
void vider_liste(void)
/* Supprime tous les éléments de la liste */
{
if(liste_vide()) {
printf("La liste est deja vide.\n");
} else {
en_queue();
while(!liste_vide()) {
oter_elt();
}
}
}
int main(void)
{
QUEUE Q;
init(&Q);
int val;
en_queue(&Q,1);
en_queue(&Q,2);
en_queue(&Q,3);
en_queue(&Q,4);
en_queue(&Q,5);
en_queue(&Q,6); //若为长度为6的队列，只能放5个元素
traverse_queue(&Q);
if(out_queue(&Q,&val))
{
printf("出队成功！出队元素为:%d\n",val);
}
else
{
printf("出队失败！\n");
}
traverse_queue(&Q);
return 0;
}
int ComSendChar(
char character)
{
int retval;
/* interrupt driven send */
if (0x0 == (comm_status.modem & 0x40))
RaiseDtr();
retval = en_queue(Serial_Out_Queue, character);
if (-1 != retval)
outp(ComBase + INT_EN, RX_INT | TBE_INT | ERR_INT | RS_INT);
return retval;
}
void generation_mob_suivante(t_cellule grille[N][M],t_coord personnage){
t_coord coordonnee;
init_liste();
for(coordonnee.x=0;coordonnee.x<N;coordonnee.x++){
for(coordonnee.y=0;coordonnee.y<M;coordonnee.y++){
//printf("\nX=%d,Y=%d",coordonnee.x,coordonnee.y);
if(grille[coordonnee.x][coordonnee.y]==ennemi && !est_present(coordonnee) && chemin_possible(grille,personnage,coordonnee)){
recherche_chemin(grille,coordonnee,personnage);
en_queue();
ajout_droit(coordonnee);
}
}
}
vider_liste();
}
int ComSendString(
char *string)
{
int retval;
char *pointer;
pointer = string;
while (*pointer) {
retval = en_queue(Serial_Out_Queue, *pointer);
pointer++;
}
if (0x0 == (comm_status.modem & 0x40))
RaiseDtr();
outp(ComBase + INT_EN, RX_INT | TBE_INT | ERR_INT | RS_INT);
return retval;
}
int ComSendData(
char *buffer,
unsigned buffer_length)
{
int retval;
char *pointer;
pointer = buffer;
unsigned i;
for (i = 0; i < buffer_length; i++) {
retval = en_queue(Serial_Out_Queue, *pointer);
pointer++;
}
if (0x0 == (comm_status.modem & 0x40))
RaiseDtr();
outp(ComBase + INT_EN, RX_INT | TBE_INT | ERR_INT | RS_INT);
return retval;
}
int main(void)
{
QUEUE Q;
int val;
init(&Q);
en_queue(&Q, 1);
en_queue(&Q, 2);
en_queue(&Q, 3);
en_queue(&Q, 4);
en_queue(&Q, 5);
en_queue(&Q, 6);
en_queue(&Q, 7);
traverse_queue(&Q);
out_queue(&Q, &val);
out_queue(&Q, &val);
traverse_queue(&Q);
return 0;
}
void supprimer(void)
/* Supprime toutes les occurrences d'un entier lu au clavier */
{
int valeur;
int valeur_actuelle;
if(liste_vide()) {
printf("La liste est vide\n");
} else {
printf("\nEntrez l'entier a supprimer dans la liste : ");
scanf("%i", &valeur);
en_queue();
while(!hors_liste()) {
valeur_elt(&valeur_actuelle);
if(valeur_actuelle == valeur) {
oter_elt();
} else {
precedent();
}
}
}
}
int main(void)
{
QUEUE queue;
int value;
init(&queue);
in_state(en_queue(&queue, 1));
in_state(en_queue(&queue, 3));
in_state(en_queue(&queue, 6));
in_state(en_queue(&queue, 4));
in_state(en_queue(&queue, 9));
in_state(en_queue(&queue, 10));
in_state(en_queue(&queue, 19));
traverse(&queue);
out_state(out(&queue, &value));
printf("出队元素：%d\n", value);
traverse(&queue);
return ;
}
void make_split(Tree* MTree, Tnode * Root)
{//get all the children of a certain node
if(is_matrix(Root))
{
Root->ChildTnodeArray = 0;
Root->ChildTnodeNum = 0;
return;
}
Tnode * CreatedTnode1, * CreatedTnode2;
CreatedTnode1 = (Tnode *)malloc(sizeof(Tnode));
CreatedTnode2 = (Tnode *)malloc(sizeof(Tnode));
step_split_differentlevel(MTree, Root, CreatedTnode1, CreatedTnode2);
if(((float)CreatedTnode1->TTransactionNum) / Root->TTransactionNum < FThreshold || ((float)CreatedTnode1->TTransactionNum) / MTree->Root->TTransactionNum < WThreshold)
{//if a spliting is failed, it is based on the rate of the number of children in created1(if the bigger node is too small)
MTree->TnodeNum -= 2;
Root->ChildTnodeNum = 0;
Root->ChildTnodeArray = 0;
return;
}
//below we should deal with the case where the bigger node is so big that we should discard the rest node
else if( ((float)CreatedTnode2->TTransactionNum) / Root->TTransactionNum < FThreshold || ((float)CreatedTnode2->TTransactionNum) / MTree->Root->TTransactionNum < WThreshold)
{//if the bigger node is too big
MTree->TnodeNum --;
UsedTransactionNum -= CreatedTnode2->TTransactionNum;
en_queue(Root->ChildTnodeArray[0]);
return;
}
Tnode * CreatedTnode3;
CreatedTnode3 = step_split_samelevel(MTree,CreatedTnode2);
for(;;)
{
if(((float)CreatedTnode2->TTransactionNum) / CreatedTnode2->FatherTnode->TTransactionNum < FThreshold || ((float)CreatedTnode2->TTransactionNum) / MTree->Root->TTransactionNum < WThreshold)
{// if the bigger node is too small, we do retreat for this node
// usually we should stop spliting at this node, and this means some Transactions are discarded. We deal with that case from two aspects
if((CreatedTnode2->TTransactionNum + (float)CreatedTnode3->TTransactionNum) / CreatedTnode2->FatherTnode->TTransactionNum > DiscardThreshold)//if the number of effective children discarded is more than certain percentage of the number in Fathernode
{//we refuse to discard too many children, we would rather stop growing. And this is to handle the case where there are too many 1-transaction-nodes which is too specific
MTree->TnodeNum -= 1;
MTree->TnodeNum -= Root->ChildTnodeNum;
Root->ChildTnodeArray = NULL;
Root->ChildTnodeNum = 0;
return;
}
MTree->TnodeNum -= 2;
Root->ChildTnodeNum --;
CreatedTnode2->PreviousTnode->NextTnode = NULL;// retreat, prune at the previous node
UsedTransactionNum -= (CreatedTnode3->TTransactionNum + CreatedTnode2->TTransactionNum);
break;
}
else if(((float)CreatedTnode3->TTransactionNum) / CreatedTnode2->FatherTnode->TTransactionNum < FThreshold || ((float)CreatedTnode3->TTransactionNum) / MTree->Root->TTransactionNum < WThreshold)
{
MTree->TnodeNum -= 1;
CreatedTnode2->NextTnode = NULL;
UsedTransactionNum -= CreatedTnode3->TTransactionNum;
break;
}
CreatedTnode2 = CreatedTnode3;
CreatedTnode3 = step_split_samelevel(MTree,CreatedTnode2);
}
Tnode ** ChildTnodeArray;
ChildTnodeArray = (Tnode **)malloc(Root->ChildTnodeNum *sizeof(Tnode *));
Tnode * FirstChild;
FirstChild = *(Root->ChildTnodeArray);
for( int i = 0; i < Root->ChildTnodeNum; i ++)
{
ChildTnodeArray[i] = FirstChild;
FirstChild = FirstChild->NextTnode;
}
Root->ChildTnodeArray = ChildTnodeArray;
for( int i = 0; i < Root->ChildTnodeNum; i ++)
en_queue(Root->ChildTnodeArray[i]);
}
int main(int argc, char * argv[])
{
int opt;
while((opt = getopt(argc,argv,"c:d:f:w:i:o:")) != EOF)
{
switch(opt)
{
case 'c':
CoverThreshold = atof(optarg);
break;
case 'd':
DiscardThreshold = atof(optarg);
break;
case 'f':
FThreshold = atof(optarg);
break;
case 'w':
WThreshold = atof(optarg);
break;
case 'i':
memcpy(ReadFileName,optarg,strlen(optarg));
ReadFileName[strlen(optarg)] = '\0';
break;
case 'o':
memcpy(WriteFileName,optarg,strlen(optarg));
WriteFileName[strlen(optarg)] = '\0';
break;
}
}
/*if(argc == 2)
WThreshold = atof(argv[1]);
if(argc == 3)
{
WThreshold = atof(argv[1]);
FThreshold = atof(argv[2]);
}
if(argc == 4)
{
WThreshold = atof(argv[1]);
FThreshold = atof(argv[2]);
DiscardThreshold = atof(argv[3]);
}*/
//initialize the queue
MQueue = (Queue *)malloc(sizeof(Queue));
MQueue->QnodeNum = 0;
MQueue->StartQnode = (Qnode *)malloc(sizeof(Qnode));
MQueue->EndQnode = (Qnode *)malloc(sizeof(Qnode));
//
MQueue->StartQnode->NextQnode = MQueue->EndQnode;//recording the relationship of the virsital start node and the virtual end node initially
MQueue->EndQnode->PreviousQnode = MQueue->StartQnode;
//
MQueue->StartQnode->PreviousQnode = NULL;//no former node to the virtual start node
MQueue->EndQnode->NextQnode = NULL;//node latter node to the virtual end node
MQueue->StartQnode->QTnode = NULL;//NULL in the virtual start node
MQueue->EndQnode->QTnode = NULL;//NULL in the virtual end node
//judge m and n
char str[10000];
get_size(m);
UsedTransactionNum = m;
TransactionArray = (Transaction *)malloc(m*sizeof(Transaction));
FILE * fr = fopen(ReadFileName,"r");
for( int i = 0; i < m; i ++)
{//transfer each line of the data into a Transaction, we regard that there are no more than 20000 letters each line
fgets(str,10000,fr);
make_transaction(TransactionArray,i,str);
}
fclose(fr);
//till now, all the data in the file has been read into the memory
//initial the structure of the Tree
Tree * MTree;
MTree = (Tree *)malloc(sizeof(MTree));
MTree->TnodeNum = 0;
MTree->Root = (Tnode *)malloc(sizeof(Tnode));
MTree->Root->TTransactionNum = m;
MTree->Root->TTransaction = (Transaction *)malloc(MTree->Root->TTransactionNum * sizeof(Transaction));//allocate memory for the Transaction in the root
for( int i = 0; i < MTree->Root->TTransactionNum; i ++)
{
MTree->Root->TTransaction[i].ItemArray = TransactionArray[i].ItemArray;//copy all the elements in the TransactionArray into the MTree
MTree->Root->TTransaction[i].PacketNum = TransactionArray[i].PacketNum;
}
MTree->Root->ChildTnodeArray = NULL;
MTree->Root->ChildTnodeNum = 0;
MTree->Root->FatherTnode = NULL;
MTree->Root->NextTnode = NULL;
MTree->Root->PreviousTnode = NULL;
MTree->Root->TItem = 0;
MTree->Root->TLevel = 0;
MTree->Root->TSerialNum = 0;
en_queue(MTree->Root);
//while(MQueue->QnodeNum)
//{
//make_split(MTree,de_queue());
//}
int ThisLevelNum = 0;
int LastTnodeLevel = 0; // the level of last Tnode, it is used for judging whether the level has changed
int TillLastLevelFinishedNum = 0;
int TillThisLevelFinishedNum = 0;
//the below code is to input all the data into a file
FILE * fw = fopen(WriteFileName,"w");
Tnode * TmpTnode;
//en_queue(MTree->Root);
if( WThreshold < ((float)2)/MTree->Root->TTransactionNum)
WThreshold = ((float)2)/MTree->Root->TTransactionNum - 0.01;
while(MQueue->QnodeNum)
{
TmpTnode = de_queue();
//fprintf(fw,"TSerialNum:%d UsedTransactionNum: %d ", TmpTnode->TSerialNum, UsedTransactionNum);
//if(TmpTnode->TSerialNum > 30)
// fprintf(fw,"Father %d ", TmpTnode->FatherTnode->TSerialNum);
// fprintf(stderr,"A\n");
make_split(MTree,TmpTnode);// all the push are done inside make_split
//fprintf(fw,"AUsedTNum: %d children;: %d\n",UsedTransactionNum,TmpTnode->ChildTnodeNum);
// fprintf(stderr,"%d\n",UsedTransactionNum);
// fprintf(stderr,"%d\n",MTree->Root->TTransactionNum);
// fprintf(stderr,"%f\n",CoverThreshold);
// if(MQueue->QnodeNum == 0)
// fprintf(fw,"reach end\n");
if((float)UsedTransactionNum / MTree->Root->TTransactionNum < CoverThreshold)
{
// fprintf(stderr,"B\n");
while(MQueue->QnodeNum)
{
TmpTnode = de_queue();
fprintf(fw," Numof-Tran:%5d \n",TmpTnode->TTransactionNum);
for( int i = 0; i < TmpTnode->TLevel; i ++)
fprintf(fw,"(@%d %d)%s %c ",TmpTnode->TItem[i].PacketSeqNum, TmpTnode->TItem[i].ByteSeqNum,TmpTnode->TItem[i].Pload,hex_asc(TmpTnode->TItem[i].Pload)==10?160:hex_asc(TmpTnode->TItem[i].Pload));
fprintf(fw,"\n");
}
break;
}
if(TmpTnode->ChildTnodeNum)
continue;
fprintf(fw,"Numof-Tran:%5d \n",TmpTnode->TTransactionNum);
for( int i = 0; i < TmpTnode->TLevel; i ++)
fprintf(fw,"(@%d %d)%s %c ",TmpTnode->TItem[i].PacketSeqNum, TmpTnode->TItem[i].ByteSeqNum,TmpTnode->TItem[i].Pload, hex_asc(TmpTnode->TItem[i].Pload)==10?160:hex_asc(TmpTnode->TItem[i].Pload));
fprintf(fw,"\n");
}
//fprintf(fw,"TnodeNum: %d\n",MTree->TnodeNum);
fprintf(fw,"\n\n%.4f%% of all the Transactions are covered by this feature\n", 100 * (float)UsedTransactionNum / MTree->Root->TTransactionNum);
fprintf(fw,"Parameter: \n FThreshold: %.2f;\n WThreshold: %.2f;\n DiscardThreshold: %.2f;\n CoverThreshold: %.2f;\n",FThreshold, WThreshold, DiscardThreshold, CoverThreshold);
fclose(fw);
fprintf(stdout,"success!\n");
return 0;
}
void main()
{
person_type p, dancers[queuesize];
//键盘输入男女舞者的信息，包括姓名，性别
int i, num;
printf("输入男女dancer的总人数:\n");
scanf_s("%d", &num);
printf("输入姓名和性别（用m表示男性，用f表示女性），如: \nzhangsan\nm\n");
for (i = 0; i<num; i++)
{
scanf_s("%s", &dancers[i].name);
getchar();
scanf_s("%c", &dancers[i].sex);
if (dancers[i].sex != 'f'&&dancers[i].sex != 'm')//判断输入信息是否合法
printf("第%d个人的信息有误,请重新输入", (i--) + 1);
}
cir_queue maledancer, femaledancer;//定义两个循环队列结构体
init_queue(&maledancer);//调用init_queue()函数置空队列maledancer表示男队
init_queue(&femaledancer);//调用init_queue()函数置空队列femaledancer表示女队
for (i = 0; i<num; i++)
{
p = dancers[i];//结构体整体赋值
if (p.sex == 'f')//女的进队列femaledancer
{
en_queue(&femaledancer, p);
printf("%s进女队\n", p.name);
}
else//男的进队列maledancer
{
en_queue(&maledancer, p);
printf("%s进男队\n", p.name);
}
}
/*
int j;
int m = length_queue(&femaledancer);
int n = length_queue(&maledancer);
if(m<n)
{
person_type p;
person_type q;
person_type s;
for(j=1;j<=7;++j)
{
printf("第%d轮配对情况：\n",j);
for(int i =1;i<=m;++i )
{
p=de_queue(&maledancer);
q=de_queue(&femaledancer);
printf("男:%s",p.name);
printf("和女:%s配对成功\n",q.name);
en_queue(&maledancer,p);
en_queue(&femaledancer,q);
}
printf("男队中还有%d个人在等待!\n",n-m);
s=queue_front(&maledancer);
printf("男队中第一个等待的是：%s\n",s.name);
}
}
*/
/* int m =length_queue(&maledancer);
printf("%d",m);
traverse_queue(&maledancer);
traverse_queue(&femaledancer);
traverse_queue(&maledancer);
*/
int n;
printf("请输入要进行的轮数：\n");
scanf_s("%d", &n);
dancepartners(femaledancer, maledancer, n);
//getchar();
}
void dancepartners(cir_queue femaledancer, cir_queue maledancer, int lun)//舞伴配对函数
{
int m = length_queue(&femaledancer); //计算女队人数
int n = length_queue(&maledancer); //计算男队人数
for (int j = 1; j <= lun; ++j) //for循环表示舞会进行的轮数情况
{//通过对男女队人数的比较，进行一下操作
if (m>n)// 女队人数多于男队，女队有剩余队员
{
person_type p;
person_type q;
person_type s;
printf("------------------------");
printf("第%d轮配对情况：\n", j);
for (int i = 1; i <= n; ++i) //for循环实现配对操作
{
p = de_queue(&maledancer);
q = de_queue(&femaledancer); //出队的男女舞伴
printf("男:%s", p.name);
printf("和女:%s配对成功\n", q.name);//输出配对情况
en_queue(&maledancer, p);
en_queue(&femaledancer, q); //将出队的男女舞伴重新进队
}
//输出女队剩余队员情况,并输出在下一轮首先出场的队员姓名
printf("女队中还有%d个人在等待!\n", m - n);
s = queue_front(&femaledancer);
printf("女队中第一个等待的是：%s\n", s.name);
}
else if (m<n) //男队人数多于女队，男队有剩余队员
{
person_type p;
person_type q;
person_type s;
printf("------------------------");
printf("第%d轮配对情况：\n", j);
for (int i = 1; i <= m; ++i)
{
p = de_queue(&maledancer);
q = de_queue(&femaledancer);//出队的男女舞伴
printf("男:%s", p.name);
printf("和女:%s配对成功\n", q.name);//输出配对情况
en_queue(&maledancer, p);
en_queue(&femaledancer, q); //将出队的男女舞伴重新进队
}
//输出男队剩余队员情况,并输出在下一轮首先出场的队员姓名
printf("男队中还有%d个人在等待!\n", n - m);
s = queue_front(&maledancer);
printf("男队中第一个等待的是：%s\n", s.name);
}
else //男女队人数相等，没有剩余队员
{
person_type p;
person_type q;
// person_type s;
printf("------------------------");
printf("第%d轮配对情况：\n", j);
for (int i = 1; i <= m; ++i)
{
p = de_queue(&maledancer);
q = de_queue(&femaledancer); //出队的男女舞伴
printf("男:%s", p.name);
printf("和女:%s配对成功\n", q.name);//输出配对情况
en_queue(&maledancer, p);
en_queue(&femaledancer, q);//将出队的男女舞伴重新进队
}
printf("没有人剩余!\n");
}
}
}
int bfs(int from, int to)
{
if (from == to)
return 0;
link_queue q;
init_queue(&q);
memset(visited, 0, sizeof(visited));
queue_node p, node;
node.num = from;
visited[from] = 1;
en_queue(&q, node);
while (!is_empty_queue(q))
{
de_queue(&q, &p);
int num = p.num;
int n[4], i;
for (i = 0; i < 4; i++)
{
n[i] = num % 10;
num /= 10;
}
int x = p.num - n[0];
for (i = x; i < x+10; i++)
{
if (i == to)
return visited[p.num];
if (is_prime[i] && visited[i] == 0)
{
visited[i] = visited[p.num] + 1;
node.num = i;
en_queue(&q, node);
}
}
x = p.num - n[1]*10;
for (i = x; i < x+100; i+=10)
{
if (i == to)
return visited[p.num];
if (is_prime[i] && visited[i] == 0)
{
visited[i] = visited[p.num] + 1;
node.num = i;
en_queue(&q, node);
}
}
x = p.num - n[2]*100;
for (i = x; i < x+1000; i+=100)
{
if (i == to)
return visited[p.num];
if (is_prime[i] && visited[i] == 0)
{
visited[i] = visited[p.num] + 1;
node.num = i;
en_queue(&q, node);
}
}
x = p.num - n[3]*1000;
for (i = x+1000; i < x+10000; i+=1000)
{
if (i == to)
return visited[p.num];
if (is_prime[i] && visited[i] == 0)
{
visited[i] = visited[p.num] + 1;
node.num = i;
en_queue(&q, node);
}
}
}
destroy_queue(&q);
return 0;
}
int main(){
char* tmp_commend = NULL;//recieve input commend
char commend[10];
DATA_TYPE v;//recieve input data
node* front;//front pointer
node* rear;//rear pointer
front = NULL;//initialize
rear = NULL;
while(1){
//output hint
printf("\tEnter \'en\' or \'de\' to enqueue or dequeue,"
"\'size\' to check queue size,"
"\'q\' is to leave.\n");
if(scanf("%as", &tmp_commend)){
if(strlen(tmp_commend) > 9){
printf("Commend not found!!\n");
continue;
}
strcpy(commend,tmp_commend);
myfree(tmp_commend);
//todo string copy
}else{
printf("Aalloction fail!\n");
exit(1);
}
//to en_queu
if(!strcmp(commend,"en")){
printf("\tEnter a value to push to the queue\n");
scanf("%d",&v);
en_queue(&front, &rear,v);
en_queue_msg(v);
//to de_queue
}else if(!strcmp(commend,"de")){
if(queue_empty(front)){
printf("The queue is empty!!!\n");
}else{
de_queue_msg(de_queue(&front));
}
//to get size
}else if(!strcmp(commend,"size")){
printf("The size of queue is %d.\n",queue_size(front));
//to quit
}else if(!strcmp(commend,"q")){
printf("End process\n");
break;
//enter wrong commend
}else{
printf("Commend not found!!\n");
}
}
return 0;
}
