dead--栈队列

 创建链表

分别用头插法和尾插法创建并输出带附加头结点的单链表。
头插法是指每个新元素都插入到链表的最前面，即头结点和链表第一个元素之间；
尾插法指的是每个新元素都插入到链表的最后面。

输入描述

输入：一组整数，以EOF为结束。

输出描述

输出：分别创建好的两个链表的元素。

用例输入 1 

-4 5 8 -34 0 9 36 -1 77

用例输出 1 

-4 5 8 -34 0 9 36 -1 77 
77 -1 36 9 0 -34 8 5 -4 
#include <stdio.h>
#include <stdlib.h>typedef struct LNode 
{int data;struct LNode *next;
}LNode, *Linklist;void create_LIFO(Linklist &L, int a[], int n);	//头插法
void create_FIFO(Linklist &L, int a[], int n);	//尾插法
void printLinklist(Linklist L);	//输出链表
void DistroyLinklist(Linklist &L);	//释放链表
int main()
{Linklist L1, L2;int a[100], x, n;n = 0;while (scanf("%d", &x)!=EOF){a[n++] = x;	}create_FIFO(L2, a, n);    //尾插法建表printLinklist(L2);create_LIFO(L1, a, n);   //头插法建表printLinklist(L1);DistroyLinklist(L1);  //释放链表 DistroyLinklist(L2);return 0;
}//函数功能：头插法创建链表，链表元素类型为int        void create_LIFO(Linklist &L, int a[], int n)
{int i;Linklist p;L = (Linklist) malloc (sizeof (LNode));L-> next = NULL;    // 先建立一个带头结点的单链表for (i = 0; i <= n-1; ++i) {      p = (Linklist) malloc (sizeof (LNode));   // 生成新结点p -> data = a[i];p -> next = L -> next; L -> next = p;   // 插入到表头 }
}//* 函数功能：尾插法创建链表，链表元素类型为int         *void create_FIFO(Linklist &L, int a[], int n)
{Linklist r, p;int i;L = (Linklist)malloc(sizeof(LNode));L -> next = NULL;   //先建立一个带头结点的单链表r = L;    //r为表尾元素指针for(i = 0; i < n; ++i){p = (Linklist)malloc(sizeof(LNode));  //生成新结点p -> data = a[i];  //元素值p -> next = NULL;  r -> next = p;   r = p;   //插入到表尾}}void printLinklist(Linklist L)
{LNode *p;p = L->next;while (p!=NULL){printf("%d ",p->data);p = p->next;}printf("\n");
}void DistroyLinklist(Linklist &L)
{Linklist p;p=L;while(L != NULL){L = L -> next;   //后移L指针free(p);         //释放当前结点p = L;		     //后移p指针}
}

 单链表逆置

用尾插法创建一个带头结点的单链表，并将链表就地逆置后输出。

输入描述

输入：一组整数，以EOF为结束。

输出描述

输出：逆置后的链表元素。

用例输入 1 

-4  5  8  -34  0  9  36  -1  77

用例输出 1 

77 -1 36 9 0 -34 8 5 -4

 

#include <stdio.h>
#include <stdlib.h>typedef struct LNode 
{int data;struct LNode *next;
}LNode, *Linklist;void create_FIFO(Linklist &L);	//尾插法建表
void printLinklist(Linklist L);	//输出链表
void DistroyLinklist(Linklist &L);//销毁链表
void ReverseLinklist(Linklist &L);//逆置链表int main()
{Linklist head;create_FIFO(head);ReverseLinklist(head);printLinklist(head);DistroyLinklist(head);return 0;
}/******************************************************
* 函数名：reverseLinklist                             *
* 函数功能：逆置链表。                                *
* 入口参数：链表头指针 L                           *
* 出口参数：链表头指针 L                           *
******************************************************/
//头插法
void ReverseLinklist(Linklist &L)
{int i;Linklist p, q;p = L->next;     //p保存第一个结点的指针L->next = NULL;  //L置成空表	while(p!=NULL){      q = p->next;   //q保存下一结点的指针p->next = L->next;  //将结点p插入到L链表的表头结点后面L->next = p;		  p = q;      //p指针后移}
}/******************************************************
* 函数名：create_FIFO                                 *
* 函数功能：尾插法创建链表，链表元素类型为int         *
* 入口参数：链表头指针 L                              *
* 出口参数：链表头指针 L                              *
******************************************************/
void create_FIFO(Linklist &L)
{int num;Linklist r, p;L = (Linklist)malloc(sizeof(LNode));L -> next = NULL;   //先建立一个带头结点的单链表r = L;    //r为表尾元素指针while( scanf("%d", &num) != EOF ){p = (Linklist)malloc(sizeof(LNode));  //生成新结点p -> data = num;  //元素值p -> next = NULL;  r -> next = p;   r = p;   //插入到表尾}}/******************************************************
* 函数名：printLinklist                               *
* 函数功能：输出链表元素，链表元素类型为int           *
* 入口参数：链表头指针 L                           *
* 出口参数：无                                        *
******************************************************/
void printLinklist(Linklist L)
{LNode *p;p = L->next;while (p!=NULL){printf("%d ",p->data);p = p->next;}printf("\n");
}
/******************************************************
* 函数名：DestroyLinklist                             *
* 函数功能：释放链表                                  *
* 入口参数：链表头指针 L                              *
* 出口参数：空指针                                    *
******************************************************/
void DistroyLinklist(Linklist &L)
{Linklist p;p=L;while(L != NULL){L = L -> next;   //后移L指针free(p);         //释放当前结点p = L;		     //后移p指针}
}

单链表插入结点

已知一个有序的单链表，输入一个整数，将其插入到单链表中，
使得链表仍然保持有序。

输入描述

输入：首先输入一个n，表示单链表中结点的个数。接下来输入n个有序整数。然后输入
待插入的整数。

输出描述

输出：插入整数后的链表。

用例输入 1 

5
1 3 5 7 9
6

用例输出 1 

1 3 5 6 7 9
#include <stdio.h>
#include <stdlib.h>typedef struct LNode 
{int data;struct LNode *next;
}LNode, *Linklist;void create_FIFO(Linklist &L);	//尾插法建表
void printLinklist(Linklist L);	//输出链表
void DistroyLinklist(Linklist &L);//销毁链表
void InsertLinklist(Linklist L, int x);	//在链表插入中插入元素
int main()
{int x;Linklist head;	create_FIFO(head);   //创建链表scanf("%d", &x);InsertLinklist(head, x);  //插入结点printLinklist(head);   //输出插入后的链表DistroyLinklist(head);  //销毁链表return 0;
}//在有序链表中插入元素x，保持链表的有序性void InsertLinklist(Linklist L, int x)
{LNode *p, *q, *s;p = L->next;  q=L;//q始终保存p结点的前驱结点的指针	while (p!=NULL && p->data<x) //双指针法查找插入位置//while ( p->data<x && p!=NULL ) //双指针法查找插入位置{	q = p;		p = p->next;}//在p之前、q之后插入新元素xs = (LNode *)malloc( sizeof(LNode) );		//动态分配空间s->data = x;s->next = q->next;   //将s插入到q结点后边q->next = s;}//尾插法创建链表void create_FIFO(Linklist &L)
{int x, i, n;Linklist r, p;	L = (Linklist)malloc(sizeof(LNode));L -> next = NULL;   //先建立一个带头结点的单链表r = L;    //r为表尾元素指针scanf("%d", &n);  //输入数据个数for( i=1;i<=n; i++){scanf("%d", &x);	//输入每个数p = (Linklist)malloc(sizeof(LNode));  //生成新结点p -> data = x;  //元素值p -> next = NULL;  r -> next = p;   //插入到表尾r = p;     //尾指针后移}}void printLinklist(Linklist L)
{LNode *p;p = L->next;while (p!=NULL){printf("%d ",p->data);p = p->next;}printf("\n");
}void DistroyLinklist(Linklist &L)
{Linklist p;p=L;while(L != NULL){L = L -> next;   //后移L指针free(p);         //释放当前结点p = L;		     //后移p指针}
}

单链表删除结点

已知一个非递减有序的单链表，输入一个整数，在链表中查找，若找到，请删除这个整数，链表始终保持有序（若有多个，只删除第一个）。

输入描述

输入：首先输入一个n，表示单链表中结点的个数。接下来输入n个有序整数。然后输入
待删除的整数。

输出描述

输出：删除整数后的链表。

用例输入 1 

5
1 3 5 7 9
7

用例输出 1 

1 3 5 9  
#include <stdio.h>
#include <stdlib.h>typedef struct LNode 
{int data;struct LNode *next;
}LNode, *Linklist;void create_FIFO(Linklist &L);	//尾插法建表
void printLinklist(Linklist L);	//输出链表
void DistroyLinklist(Linklist &L);//销毁链表
void DeleteLinklist(Linklist L, int x);	//删除链表中的结点int main()
{Linklist head;int x;create_FIFO(head);scanf("%d", &x);DeleteLinklist(head, x);printLinklist(head);DistroyLinklist(head);  //销毁链表return 0;
}/******************************************************
* 函数名：DeleteLinklist                              *
* 函数功能：在有序链表中删除元素x，保持链表的有序性   *
* 入口参数：链表头指针 L                           *
* 出口参数：链表头指针 L                           *
******************************************************/
//void DeleteLinklist(Linklist L, int x)
//{
//	LNode *p, *q;
//
//	p = L->next;
//	q = L;
//	while( p!=NULL && p->data!=x ) //双指针法查找待删除结点,q总是指向p的前驱
//	{	
//		q = p;		
//		p = p->next;
//	}
//	//删除q之后元素x 
//	if( p!=NULL  )   //若p!=NULL，即链表中存在值为x的元素
//	{
//		q->next = p->next;
//		free(p);		
//	}
//}void DeleteLinklist(Linklist L, int x)
{LNode *p, *s;p = L;while( p->next!=NULL && p->next->data!=x ) //单指针法查找待删除结点的前驱{		p = p->next;}//删除p之后元素x if( p>next!=NULL  )   //若p->next!=NULL，即链表中存在值为x的元素{s = p->next;p->next = p->next->next;free(s);		}
}
/******************************************************
* 函数名：create_FIFO                                 *
* 函数功能：尾插法创建链表，链表元素类型为int         *
* 入口参数：链表头指针 L                              *
* 出口参数：链表头指针 L                              *
******************************************************/
void create_FIFO(Linklist &L)
{int x, i, n;Linklist r, p;	L = (Linklist)malloc(sizeof(LNode));L -> next = NULL;   //先建立一个带头结点的单链表r = L;    //r为表尾元素指针scanf("%d", &n);  //输入数据个数for( i=1;i<=n; i++){scanf("%d", &x);	//输入每个元素值p = (Linklist)malloc(sizeof(LNode));  //生成新结点p -> data = x;  //元素值p -> next = NULL;  r -> next = p;   //插入到表尾r = p;     //尾指针后移}}/******************************************************
* 函数名：printLinklist                               *
* 函数功能：输出链表元素，链表元素类型为int           *
* 入口参数：链表头指针 L                           *
* 出口参数：无                                        *
******************************************************/
void printLinklist(Linklist L)
{LNode *p;p = L->next;while (p!=NULL){printf("%d ",p->data);p = p->next;}printf("\n");
}
/******************************************************
* 函数名：DestroyLinklist                             *
* 函数功能：释放链表                                  *
* 入口参数：链表头指针 L                              *
* 出口参数：空指针                                    *
******************************************************/
void DistroyLinklist(Linklist &L)
{Linklist p;p=L;while(L != NULL){L = L -> next;   //后移L指针free(p);         //释放当前结点p = L;		     //后移p指针}
}/*
while( p->data==x ){q->next = p->next;free(p);p = q->next;}
*/

多项式相加

给定两个多项式，实现两个多项式相加算法。

输入描述

输入：第一行输入包含两个整数m, n，后续为m行和n行数据，m, n分别代表两个多项式的
项数；后续每一行代表多项式的项，包含a, b两个数据，表示该项的系数和指数。

输出描述

输出：从较高指数到较低指数，依次输出求得的和。每行一项，格式与输入相同，但无需输
出项数，系数为0的项也不输出。

用例输入 1 

2  3 
1  2
1  1
2  2 
1  1 
2  0

用例输出 1 

3 2 
2 1 
2 0
#include <stdio.h>
#include <stdlib.h>typedef  struct LNode 
{int   coef;		//多项式每项的系数int   exp; 		//多项式每项的指数struct  LNode  * next;	//指向下一项的指针
}LNode, *Linklist;
typedef  Linklist Polynomial;void create_FIFO(Polynomial &L, int n);	//尾插法
void mergeLinklist(Polynomial ha, Polynomial &hb, Polynomial &hc);//多项式相加
void printLinklist(Polynomial L);	//输出链表
void DistroyLinklist(Linklist &L); //销毁链表int main()
{Polynomial La, Lb, Lc;int m, n;scanf("%d%d", &m, &n);	create_FIFO(La, m);create_FIFO(Lb, n);mergeLinklist(La, Lb, Lc);		//多项式相加printLinklist(Lc);DistroyLinklist(Lc);return 0;
}/******************************************************
* 函数名：create_FIFO                                 *
* 函数功能：尾插法创建链表，链表元素类型为            *
* 入口参数：链表头指针 L                           *
* 出口参数：链表头指针 L                           *
******************************************************/
void create_FIFO(Polynomial &L, int n)
{Polynomial p, r;int i, coef, exp;L = (Polynomial)malloc( sizeof(LNode) );L -> next = NULL;   //先建立一个带头结点的单链表r = L;    //r为表尾元素指针for (i=0; i<n; i++){scanf("%d%d", &coef, &exp);p = (Polynomial)malloc( sizeof(LNode) );		p->coef = coef;p->exp = exp;p->next = NULL;r->next = p; //插入到表尾r = p; //尾指针后移}}		/******************************************************
* 函数名：printLinklist                               *
* 函数功能：输出链表元素，链表元素类型为int           *
* 入口参数：链表头指针 head                           *
* 出口参数：无                                        *
******************************************************/
void printLinklist(Polynomial L)
{Polynomial p;p = L->next;while (p!=NULL) {printf("%d %d\n",p->coef, p->exp);p = p->next;}
}/******************************************************
* 函数名：mergeLinklist                                     *
* 函数功能：多项式相加                                *
* 入口参数：两个多项式链表头指针 ha, hb               *
* 出口参数：相加后的多项式链表头指针hc                *
******************************************************/void mergeLinklist(Polynomial ha, Polynomial &hb, Polynomial &hc)
{      Polynomial p, q, r, q1, p1;int x;p = ha->next;      q = hb->next;hc = r = ha;while (p!=NULL && q!=NULL){	if (p->exp > q->exp){       r->next = p;	//a表指数大 r = p;p = p->next;}else if (p->exp < q->exp){   r->next = q;	//b表指数大r = q;q = q->next;}	else //两表指数相等{       p->coef = p->coef + q->coef;  if (p->coef != 0) //系数不为0 {   r->next = p;r = p;p = p->next;  //p指针后移}else   //系数为0{p1=p;p = p->next; //p后移free(p1);    //释放a表中对应结点}     //释放b表中对应结点q1 = q; q = q->next; free(q1); }	   	  	}if (p!=NULL) r->next = p;else	r->next = q;free(hb);     
}/******************************************************
* 函数名：DestroyLinklist                             *
* 函数功能：释放链表                                  *
* 入口参数：链表头指针 L                              *
* 出口参数：空指针                                    *
******************************************************/
void DistroyLinklist(Linklist &L)
{Linklist p;p=L;while(L != NULL){L = L -> next;   //后移L指针free(p);         //释放当前结点p = L;		     //后移p指针}
}

 小孩报数问题

有N个小孩围成一圈，给他们从1开始依次编号，现指定从第W个开始报数，报到第S个时，
该小孩出列，然后从下一个小孩开始报数，仍是报到S个出列，如此重复下去，直到所有的
小孩都出列（总人数不足S个时将循环报数），求小孩出列的顺序。

输入描述

第一行输入小孩的人数N（N<=64）
接下来每行输入一个小孩的名字(人名不超过15个字符)
最后一行输入W,S (W < N)，用逗号","间隔

输出描述

按人名输出小孩按顺序出列的顺序，每行输出一个人名

用例输入 1 

5
Xiaoming
Xiaohua
Xiaowang
Zhangsan
Lisi
2,3

用例输出 1 

Zhangsan
Xiaohua
Xiaoming
Xiaowang
Lisi
#include <stdio.h>
#include <string.h>
#include <stdlib.h>typedef struct LNode 
{char name[16];struct LNode *next;
}LNode, *Linklist;void create_FIFO(Linklist &L, int n);	//尾插法建循环链表
void Joseph(Linklist &L, int start, int m);	//约瑟夫环int main()
{Linklist head;int n, w, s;scanf("%d", &n);getchar();  //接收输入n后面的回车create_FIFO(head,n);scanf("%d,%d", &w, &s);Joseph(head, w, s);return 0;
}/******************************************************
* 函数名：Joseph                                      *
* 函数功能：输出出圈顺序                              *
* 入口参数：链表头指针 L ，起始位置start 报数n                          *
* 出口参数：链表头指针 L                           *
******************************************************/
void Joseph(Linklist &L, int start, int m)
{LNode *p, *q;int i, k;p = L;for( i=1; i<start; i++ ){p = p->next;}while( p->next != p ) {	for( k=1; k<m; k++ ){q = p ;					p = p->next;}printf("%s", p->name);q->next = p->next;free(p);p = q->next;}printf("%s",p->name);free(p);
}/******************************************************
* 函数名：create_FIFO                                 *
* 函数功能：尾插法创建链表，链表元素类型为int         *
* 入口参数：链表头指针 L , 结点个数 n                              *
* 出口参数：链表头指针 L                              *
******************************************************/
void create_FIFO(Linklist &L, int n)
{int  i;Linklist r, p;	L = (Linklist)malloc(sizeof(LNode));fgets(L->name,16,stdin);	//输入第一个元素值//scanf("%s", L->name);L -> next = L;   //先建立一个结点的循环链表r = L;    //r为表尾元素指针for( i=2;i<=n; i++){		p = (Linklist)malloc(sizeof(LNode));  //生成新结点fgets(p->name,16,stdin);	//输入每个元素值	//scanf("%s", L->name);p -> next = L ;  //创建循环链表		r -> next = p;   //插入到表尾r = p;     //尾指针后移}}

双向报数

编号为1,2,…,100的100位小朋友依次成一列。从1号开始1、2、3报数，凡报到3者出列，
直至报数到队列尾部。此后，又从队列尾开始反向1、2、3报数，凡报到3者同样出列。这样
反复顺逆报数，直至队列中剩下2个小朋友为止，问最后未出列的两个小朋友的编号为多少？
第50个出列的是哪一个？

输入描述

此题无输入

用例输入 1 

无

用例输出 1 

无

提示

（Tip：可采用双向链表结构，为方便，除附加头结点之外，额外增加一个附加尾结点）

#include <stdio.h>
#include <stdlib.h>
#define N 100
#define M 3typedef struct LNode {int data;struct LNode *next;struct LNode *prior;	//前驱指针
}LNode, *Linklist;void create_FIFO(Linklist &head, Linklist &tail, int n);	//尾插法
void Joseph(Linklist head, Linklist tail, int m);	//
void printList(Linklist head, Linklist tail);
int main()
{Linklist head, tail;create_FIFO(head,tail, N);Joseph(head, tail, M);printList(head,tail);return 0;
}void printList(Linklist head, Linklist tail)
{LNode *p;p = head->next;while (p!=tail){printf("%4d",p->data);p = p->next;}}
/******************************************************
* 函数名：Joseph                                      *
* 函数功能：输出出圈顺序                              *
* 入口参数：链表头指针 head                           *
* 出口参数：链表头指针 head                           *
******************************************************/
void Joseph(Linklist head, Linklist tail, int m)
{LNode *p, *q;int k, count=0, fiftieth;do {p = head->next;while (p!=tail) { 	for (k=1; p!=tail && k<m; k++){p = p->next;}if (p!=tail) {count++;if (count==50)fiftieth = p->data;q = p->prior;q->next = p->next;p->next->prior = q;free(p);p = q->next;}}p = tail->prior;while (p!=head) { 	for (k=1; p!=head && k<m; k++){p = p->prior;}if (p!=head) {count++;if (count==50)fiftieth = p->data;q = p->next;q->prior = p->prior;p->prior->next = q;free(p);p = q->prior;}}}while (head->next->next!=tail->prior);//printf("\n最后未出列的两位小盆友编号是：");printf("%d  %d\n",head->next->data, tail->prior->data);
//	printf("第50个出列的小盆友编号是：");printf("%d\n", fiftieth);
}/******************************************************
* 函数名：create_FIFO                                 *
* 函数功能：尾插法创建双向链表，链表元素类型为int     *
* 入口参数：链表头指针 head, 链表尾指针 tail          *
* 出口参数：双向链附加头结点指针 head,链表尾指针 tail *
******************************************************/
void create_FIFO(Linklist &head, Linklist &tail, int n)
{LNode *p, *q;int i;head = (LNode *) malloc(sizeof(LNode));		//动态分配空间tail = (LNode *) malloc(sizeof(LNode));		//动态分配空间head->next = tail;head->prior = NULL;tail->next = NULL;tail->prior = head;p = head;for(i=1; i<=n; i++) {q = (LNode *)malloc(sizeof(LNode));		q->data = i;q->next = p->next;p->next->prior = q;p->next = q;q->prior = p;p = q;}
}

括号匹配

给定一串字符，不超过100个字符，可能包括括号、数字、字母、标点符号、空格，编程
检查这一串字符中的( ) ,[ ],{ }是否匹配。

输入描述

输入：在一行中给出一行字符串，不超过100个字符，可能包括括号、数字、字母、标点
符号、空格。

输出描述

输出：如果括号配对，输出yes，否则输出no。

用例输入 1 

sin(10+20)
{[}]

用例输出 1 

yes
no 
#include <stdio.h>
#define Maxsize 100typedef struct stack {char data[Maxsize];int top;
}Stack;void initStack(Stack &s);
int emptyStack(Stack s);
void push(Stack &s, char x); 
char pop(Stack &s);
int judge(char str[]);int main()
{char str[Maxsize]; while(gets(str)){if (judge(str))printf("yes\n");elseprintf("no\n");}	return 0;
}int judge(char str[])
{Stack s;int  i;char a, b;initStack(s);i = 0;while (str[i]!='\0'){if (str[i]=='(' || str[i]=='[' ||str[i]=='{')	//左边括号，则压栈 push(s, str[i]);else if (str[i] == ')')		//右边括号 {if (emptyStack(s))		//栈空，说明之前没有对应的左括号 return 0;a = pop(s);if (a!='(')		//弹出的左括号跟当前的右括号不配对 return 0;}else if (str[i] == ']'){if (emptyStack(s))return 0;a = pop(s);if (a!='[')return 0;}else if (str[i] == '}'){if (emptyStack(s))return 0;a = pop(s);if (a!='{')return 0;}i++;				}if (emptyStack(s))return 1;else return 0;		
}int emptyStack(Stack s)
{return s.top == 0;
}void initStack(Stack &s)
{s.top = 0;
}void push(Stack &s, char x)
{s.data[s.top++] = x;
}char pop(Stack &s)
{return s.data[--s.top];
}

看病要排队

看病要排队这个是地球人都知道的常识。
不过经过细心的0068的观察，他发现了医院里排队还是有讲究的。 0068所去的医院有三个医生（汗，这么少）
同时看病。而看病的人病情有轻重，所以不能根据简单的先来先服务的原则。所以医院对每种病情规定了10种
不同的优先级。级别为10的优先权最高，级别为1的优先权最低。医生在看病时，则会在他的队伍里面选择一个
优先权最高的人进行诊治。如果遇到两个优先权一样的病人的话，则选择最早来排队的病人。
现在就请你帮助医院模拟这个看病过程。

输入描述

输入数据包含多组测试，请处理到文件结束。
每组数据第一行有一个正整数N(0<N<2000)表示发生事件的数目。
接下来有N行分别表示发生的事件。
一共有两种事件：
1:“IN A B”,表示有一个拥有优先级B的病人要求医生A诊治。(0<A<=3,0<B<=10)
2:“OUT A”,表示医生A进行了一次诊治，诊治完毕后，病人出院。(0<A<=3)

输出描述

对于每个"OUT A"事件，请在一行里面输出被诊治人的编号ID。如果该事件时无病人需要诊治，则输出"EMPTY"。
诊治人的编号ID的定义为：在一组测试中，"IN A B"事件发生第K次时，进来的病人ID即为K。从1开始编号。

用例输入 1 

7
IN 1 1
IN 1 2
OUT 1
OUT 2
IN 2 1
OUT 2
OUT 1
2
IN 1 1
OUT 1

用例输出 1 

2
EMPTY
3
1
1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>typedef struct qdata
{int prior;int patient;
} QData;
typedef struct qnode
{QData data;struct qnode * next;
} QNode, *LinkQueue;int emptyQueue(LinkQueue Q);
QData DeQueue(LinkQueue Q);
void EnQueue(LinkQueue Q, QData x);int main()
{char cmd[4];QData x;LinkQueue Q[4];int i, n, k, doctor;while (scanf("%d", &n)!=EOF){getchar();//初始化空队列for (i=1; i<4; i++){Q[i] = (QNode *)malloc(sizeof(QNode));Q[i]->next = NULL;}for (i=0, k=1; i<n; i++){scanf("%s %d", cmd, &doctor);  //读入命令和医生编号if (strcmp(cmd,"IN")==0){scanf("%d", &x.prior); //读入优先级x.patient = k;		   //病人编号EnQueue(Q[doctor], x); //病人按优先级进入队列k++;}else{if (emptyQueue(Q[doctor]))  //队列为空printf("EMPTY\n");else{x = DeQueue(Q[doctor]);	  //队首病人出队printf("%d\n", x.patient);	//输出病人编号}}}}return 0;
}//进队列，按优先级
void EnQueue(LinkQueue Q, QData x)
{QNode *p,*r;p = Q;while(p->next&&p->next->data.prior>=x.prior){p = p->next;}r = (QNode *)malloc(sizeof(QNode));r->data = x;r->next = p->next;p->next = r;
}//出队列
QData DeQueue(LinkQueue Q)
{QNode * p;QData x;p = Q->next;Q->next = p->next;x = p->data;free(p);return x;
}//判断队列是否为空
int emptyQueue(LinkQueue Q)
{return Q->next==NULL;
}

简单计算器

Roliygu曾经沉迷于SICP大半个学期，在沉迷期间，他对LISP语言的算术表达式很感兴趣，于是类比写出了一种后缀表达式。

后缀表达式是指的将两个操作数之间的操作符移到两个操作数之后的表达式。比如原来的表达式为（1-2）*（4+5）=-9，写成后缀表达式就成了

1 2 - 4 5 + *

输入：

第一行输入n，0<n<10，表示有n行表达式

接下来的n行，每行一个后缀表达式，保证表达式合法，且不使用除四则运算之外的操作。不会输入负数

输出：

输出n行，每行为输入表达式的最终结果，结果保留两位小数，不需要高精度数。

注意：有多位数输入和小数输入

#include <stdio.h>
#define Maxsize 50typedef struct stack 
{float data[Maxsize];int top;
}Stack;void initStack(Stack &s);
void push(Stack &s, float x); 
float pop(Stack &s);int main()
{Stack s;char str[80]; int  i, j, n, ten;float a, b;scanf("%d",&n);	getchar();for (i=0; i<n; i++){initStack(s);//gets(str);fgets(str, 80, stdin);j = 0;while (str[j]!='\0'&&str[j]!='\n'){//整数部分if (str[j]>='0' && str[j]<='9'){a = 0;while(str[j] && (str[j]>='0' && str[j]<='9')){a = a*10 + str[j]-'0';j++;}push(s, a);}//小数部分else if (str[j]=='.'){j++;		//跳过小数点b = 0;ten  = 1;while (str[j] && (str[j]>='0' && str[j]<='9')){b = b*10 + str[j]-'0';ten = ten * 10;j++;}a = pop(s);a = a + b / ten;push (s, a);}//跳过空格else if (str[j]==' '){j++;}//遇到运算符else{b = pop(s);a = pop(s);switch(str[j]){case '+':	a = a + b;	break;case '-':	a = a - b;	break;case '*':	a = a * b;	break;case '/':	a = a / b;	break;		}push(s,a);j++;}}a = pop(s);printf("%.2f\n", a);}return 0;
}void initStack(Stack &s)
{s.top = 0;
}void push(Stack &s, float x)
{s.data[s.top++] = x;
}float pop(Stack &s)
{return s.data[--s.top];
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/bicheng/28385.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

ffmpeg解封装rtsp并录制视频-（2）使用VLC模拟一个rtsp服务器并用ffmpeg解封装该rtsp流

ffmpeg解封装rtsp并录制视频-（2）使用VLC模拟一个rtsp服务器并用ffmpeg解封装该rtsp流

VCL模拟服务器并打开播放该视频文件&#xff1a; - 准备好一个mp4文件&#xff0c;打开vlc软件 - 选择“媒体”》“流” - 添加一个mp4文件 - 点击下方按钮选择“串流” - 下一步目标选择rtsp 点击“添加” - 端口默认8554 - 路径设置 /test - 用…
阅读更多...
代码随想录算法训练营Day37|56.合并区间、738.单调递增的数字、968.监控二叉树

代码随想录算法训练营Day37|56.合并区间、738.单调递增的数字、968.监控二叉树

合并区间 56. 合并区间 - 力扣&#xff08;LeetCode&#xff09; 和之前的思路类似&#xff0c;先创建一个ans二维数组&#xff0c;创建start和end来指明添加进入ans数组的区间下标&#xff0c;先对数组按照首元素排序从小到大排序后&#xff0c;根据当前元素是否小于下一个元…
阅读更多...
【three.js】自定义物体形状BufferGeometry

【three.js】自定义物体形状BufferGeometry

目录 一、认识缓冲类型几何体BufferGeometry 二、将各个顶点连线 一、认识缓冲类型几何体BufferGeometry threejs的长方体BoxGeometry、球体SphereGeometry等几何体都是基于BoxGeometry类构建的，BufferGeometry是一个没有任何形状的空几何体，你可以通过BufferGeometry自定…
阅读更多...
SinNerf理解和效果

SinNerf理解和效果

文章目录 SinNerf 解决的问题方法和结构自己训练的效果 SinNerf 解决的问题 该方法主要解决的问题是&#xff1a; 现有都使用多张照片来进行nerf 表示的学习&#xff0c;这篇文章的话&#xff0c;主要是想使用一张单视角的照片来Nerf表示的学习。通过从单张照片中得到的伪标签…
阅读更多...
【SpringBoot集成Spring Security】

【SpringBoot集成Spring Security】

一、前言 Spring Security 和 Apache Shiro 都是安全框架&#xff0c;为Java应用程序提供身份认证和授权。 二者区别 Spring Security&#xff1a;重量级安全框架Apache Shiro&#xff1a;轻量级安全框架 关于shiro的权限认证与授权可参考小编的另外一篇文章 &#xff1a; …
阅读更多...
IDEA模版快速生成Java方法体

IDEA模版快速生成Java方法体

新建模版组myLive 在模版组下新建模版finit 在模版text内输入以下脚本 LOGGER.info("$className$.$methodName$>$parmas1$", $parmas2$); try {} catch (Exception e) {LOGGER.error("$className$.$methodName$>error:", e); }LOGGER.info("$c…
阅读更多...
win10没有Hyper-v的解决方法

win10没有Hyper-v的解决方法

win10没有Hyper-v的解决方法 问题&#xff1a;最近想装下docker&#xff0c;但是在控制面板-程序-启用或关闭Windows功能下找不到Hyper-v节点。 废话不多说&#xff0c;直接上实操教程 1.将下面命令复制到文本文档中&#xff0c;并将文档重命名Hyper.cmd pushd "%~dp0&q…
阅读更多...
实用小工具-python esmre库实现word查找

实用小工具-python esmre库实现word查找

python esmre库实现word查找 前言&#xff1a; 在文本中匹配特定的字符串&#xff0c;一般可以用普通的字符串匹配算法&#xff0c;KMP算法&#xff1b; python中提供了一个库&#xff0c;esmre, 通过预先将字符串存到esm对象中&#xff0c;利用这些字符串从候选的字符串中进行…
阅读更多...
Spring Boot实战：图书信息网站

Spring Boot实战：图书信息网站

实战概述&#xff1a;Spring Boot图书信息网站开发 项目背景 随着数字化时代的到来&#xff0c;图书信息网站为用户提供了一个便捷的在线浏览和购买图书的平台。本实战项目旨在通过Spring Boot框架开发一个图书信息网站&#xff0c;实现图书展示、用户登录和管理等功能。 项…
阅读更多...
【Bazel 】- Examples to build C++ code

【Bazel 】- Examples to build C++ code

Examples to build C code This folder is part of the C Bazel Tutorial, found at https://bazel.build/start/cpp This package will showcase how to build C code in stages. 此文件夹是 C Bazel 教程的一部分&#xff0c;位于 https://bazel.build/start/cpp 此包将展…
阅读更多...
Android 自定义View

Android 自定义View

我们所有的试图都是起源于自定义View&#xff0c;包括ViewGroup也是继承于它&#xff0c;可以说它是视图组件之父。 我们可以从它的大致流程来分为四个部分&#xff1a; 构造方法&#xff0c;onMeasure&#xff0c;onLayout&#xff0c;onDraw 构造方法&#xff1a; 它主要有…
阅读更多...
如何判断一个js对象是否存在循环引用

如何判断一个js对象是否存在循环引用

一、背景 在前端JSON.stringfy是我们常用的一个方法&#xff0c;可以将一个对象序列化。 例如将如下对象序列化 const person { name: kalory, age:18}JSON.stringfy(person) // 结果 {"name":"kalory","age":18}将一个数组序列化const arr …
阅读更多...
什么是分布式光伏系统？

什么是分布式光伏系统？

随着全球对可再生能源和环保技术的日益重视&#xff0c;分布式光伏系统已成为电力领域中不可或缺的一部分。它代表了一种新兴的能源供应方式&#xff0c;具有显著的环保和经济价值。 一、定义与特点 分布式光伏系统是指将光伏组件安装在用户侧&#xff0c;如屋顶、墙面等建筑物…
阅读更多...
OperationalError: (_mysql_exceptions.OperationalError)

OperationalError: (_mysql_exceptions.OperationalError)

OperationalError: (_mysql_exceptions.OperationalError) (2006, MySQL server has gone away) 这个错误通常表示客户端（例如你的 Python 程序使用 SQLAlchemy 连接到 MySQL 数据库）和 MySQL 服务器之间的连接被异常关闭了。这个问题可能由多种原因引起，以下是一些常见的原…
阅读更多...
ModuleNotFoundError: No module named ‘distutils‘的解决办法

ModuleNotFoundError: No module named ‘distutils‘的解决办法

最近想试试odoo17&#xff0c;在windows环境下&#xff0c;想安装试验一下&#xff0c;结果老出现oduleNotFoundError: No module named ‘distutils‘错误。查了一下&#xff0c;以为是python版本导致的&#xff0c;结果试了很多版本如下&#xff1a; 试了几个&#xff0c;每个…
阅读更多...
Java——变量作用域和生命周期

Java——变量作用域和生命周期

一、作用域 1、作用域简介 在Java中&#xff0c;作用域&#xff08;Scope&#xff09;指的是变量、方法和类在代码中的可见性和生命周期。理解作用域有助于编写更清晰、更高效的代码。 2、作用域 块作用域&#xff08;Block Scope&#xff09;&#xff1a; 块作用域是指在…
阅读更多...
windows设备/路由设备上ip地址如何查看、使用

windows设备/路由设备上ip地址如何查看、使用

在Windows设备上查看本地IP地址&#xff08;IPv4和IPv6&#xff09;&#xff1a; 使用命令提示符&#xff1a; 打开命令提示符&#xff08;在Windows中按Win R&#xff0c;然后输入"cmd"并按Enter&#xff09;。在命令提示符窗口中&#xff0c;输入以下命令以查看…
阅读更多...
Redis缓存穿透、缓存雪崩和缓存击穿的解决方案

Redis缓存穿透、缓存雪崩和缓存击穿的解决方案

Redis缓存穿透、缓存雪崩和缓存击穿的解决方案 引言 Redis作为当前非常流行的内存数据结构存储系统&#xff0c;以其高性能和灵活性被广泛应用于缓存、消息队列、排行榜等多种场景。然而&#xff0c;在实际使用过程中&#xff0c;可能会遇到缓存穿透、缓存雪崩和缓存击穿等问…
阅读更多...
软件服务中的 SLA 到底是什么？

软件服务中的 SLA 到底是什么？

目录 什么是 SLA SLA 的组成部分 SLA 的重要性 制定和执行 SLA 小结 平常使用云服务或者使用 SaaS 服务时&#xff0c;厂商一般都会承诺 SLA 达到多少&#xff0c;没有达到的话会如何赔偿&#xff0c;例如云服务的稳定性一般会承诺4个9&#xff08;即99.99%&#xff09;。…
阅读更多...
C语言：进程

C语言：进程

一、进程标识符pid 类型pid_t&#xff0c;16位整型数三万多个。2的16次方65535. 进程标识是顺次向下使用。与文件描述符不一样。 pid_t getpid(void); pid_t getppid(void); 进程正常终止 1.从main函数返回 2.调用exit 3.调用_exit或_Exit 4.最后一个线程…
阅读更多...
最新文章

Copyright @ 2022~2023