队的算法
1. 试写出循环队列出队、入队的算法（用C语言给出主要部分即可）
#define Max 300
typedef struct
{
int tail,head;
int a[Max];
}queue;
void enqueue(int key,queue&q)
{
q.a[q.tail]=key;
q.tail=(q.tail+1)%Max;
}
int dequeue(queue&q)
{
int key;
key=q.a[q.head];
q.head=(q.head+1)%Max;
return key;
}
用了c++引用。。。。。。没有入队前的判断是否满了以及出队前判断是否为空，这个你应该懂的
2. 循环队列中入队与出队算法
如果循环队列每个元素有两个指针，一个指向其前面的元素pPre，一个指向后面的元素pNext，出对和入队就是修改一下指针啊。
比如指向要出队的元素的指针是 pDel,那么出队就应该是：
pDel->pPre->pNext = pDel->pNext;
pDel->pNext->pPre = pDel->pPre;
如果循环队列每个元素只有一个指向其后元素的指针pNext，那么需要遍历整个队列，找到要出队元素的前一个元素，然后就和上面的算法差不多了。
如果经常要进行出队操作，在设计数据结构的时候还是建议每个元素使用两个指针。
3. 在数据结构入队与出队的算法中,为什么Q->rear=(Q->rear+1)%MAXSIZE与Q->data[Q->rear]=x可以互换
后者是让队列尾指针后移一位，前者是判断队列是否已满。
4. 队列是什么意思
队列是常用数据结构之一。队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。
为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又为先进先出（FIFO—first in first out）线性表。
(4)队的算法扩展阅读：
队列的基本运算
1、初始化队列：Init＿Queue（q） ，初始条件：队q 不存在。操作结果：构造了一个空队；
2、读队头元素：Front＿Queue（q，x），初始条件： 队q 存在且非空，操作结果： 读队头元素，并返回其值，队不变；
3、出队操作： Out＿Queue（q，x），初始条件： 队q 存在且非空，操作结果： 删除队首元素，并返回其值，队发生变化；
4、入队操作： In＿Queue（q，x），初始条件： 队q 存在。操作结果： 对已存在的队列q，插入一个元素x 到队尾，队发生变化；
5、判队空操作：Empty＿Queue（q），初始条件： 队q 存在，操作结果： 若q 为空队则返回为1，否则返回为0。
5. 请解答入队出队算法在循环队列中设置一个标志flag当front=rear且flag=0时为队空front=rear且flag=1队满
这个问题很简单!标志tag初值为0，入队成功就设置为1、出队成功就设置为0 这样来看： 如果当前标志为0，则代表前一次执行的操作是出队，因此队列中一定至少有一个空位置可以进队 类似地： 如果当前标志为1，则代表前一次执行的操作是进队，因此队列中一定至少有一个元素可以出队 注意循环队列出队时是队头在追赶队尾（沿着队列中元素的位置向队尾方向移动），如果追上了，就是队空条件：rear==front&&tag==0，这是在出队操作完成之后 而循环队列进队时是队尾追赶队头（沿着空位置向队头方向移动），如果追上了，就是队满条件：rear==front&&tag==1，这是在进队操作完成之后
6. 写出队列的入队及出队算法
入队算法
linklist in_queue(linklist rear,datatype x)
{
s=new lnode;
s->data=x;
s->next=rear->next;
rear->next=s;
rear=s;
return(rear );
}
出队算法
linklist out_queue(linklist rear,datatype *x)
{
if (rear->next==rear)
return(NULL);
q=rear->next->next;
if (q==rear)
{
rear=rear->next;
rear->next=rear;
}
else
{
rear->next->next=q->next;
}
*x=q->data;
delete q;
return(rear);
}
7. 请解答入队出队算法 在循环队列中设置一个标志flag 当front=rear且flag=0时为队空 front=rear且flag=1队满
当有数据入队时如果front=rear那么flag被置为1，因为这时队列满；出队时如果front=rear,flag被置为0，因为这时队列空。
当队列只有一个元素时，front==rear；当队为空时，front==(rear+1)%n；进队的操作为：rear = (rear + 1) % n ;Queue[rear] = elem ;元素正好在下标为0的位置，此时front==rear==0。
“队列非空时front和rear分别指向队头元素和队尾元索”意思就是front和rear都是“实指”，理解中front是“虚指”，不同教材采用的方法不一样，一般题目中会说明。
(7)队的算法扩展阅读：
在循环队列中，当队列为空时，有front=rear，而当所有队列空间全占满时，也有front=rear。为了区别这两种情况，规定循环队列最多只能有MaxSize-1个队列元素，当循环队列中只剩下一个空存储单元时，队列就已经满了。因此，队列判空的条件是front=rear，而队列判满的条件是front=（rear+1)%MaxSize。
8. 算法问题，求解6个球队比赛的调度方法，使得所有的队能在最短的时间内相互之间完成比赛
首先确定还需要最少的比赛星期数--可由已经比赛最少的D来确定，因为等D的比赛完至少需要四周。
然后，尽可能在前几周使比赛场数达到最大--3场。下面以A为例分析，其他等同。用图来表示比赛情况：比赛过的两队用线连接。
第一周：因为A只剩下DEF没有比赛，所以A在第一周内的比赛可能有：AD-BC、AD-BE-CF、AE-BC-DF、AF-DC-BE。按照字母表排序（通常程序也是这么来的），选择AD-BE-CF。画图。
第二周：A还有EF没有比过，故有AE-BC-DF，其他的可能就只有AE一场，故排除。画图。
第三周：AF-CD。从这周开始就有轮空了。画图。
第四周：只剩下DE了。。。到此结束~
3.P.S.其实可以从ABCDEF中任何一个队来这样分析，我想到了就是：按照字母顺序开始分析；按照每周比赛完之后还剩余比赛场数最大开始分析（一直是D）；还有剩余比赛场数最少等等
觉得思路都差不多了
9. 比赛场数计算方法：队数*（队数—1）/2的公式是怎么推算出来的
问题：今有n个赛队参加比赛，每两个队比赛一场，问一共比赛多少场？
解：其中的1队要与其余（n-1）队各赛1次共（n-1）次，照此计算n个队总共比赛n(n-1)次；不过这种计算中有重复，因为每两个队是比赛1场而非2场，所以答案是共比赛n(n-1)场。
(9)队的算法扩展阅读：
简便运算算法
1、加法结合律
加法结合律为(a+b)+c=a+(b+c)。
例如，8+1+9=8+(1+9)=8+10=18
2、加法交换律
a+c=c+a。
例如，8+5=5+8=13。
3、乘法结合律
(axb)xc=ax(bxc)。
例如，3x2.5x4=3x(2.5x4)=3x10=30。
4、乘法分配律
(a+b)xc=axc+bxc。
xy'=y(x-1),
分离变量得dy/y=(x-1)dx/x=(1-1/x)dx,
积分得lny=x-lnx+lnc,
y=(c/x)e^x,为所求。
10. 利用两个栈S1和S2模拟一个队列，写出入队和出队的算法，可用栈的基本操作
// s1是容量为n的栈，栈中元素类型是elemtp。本函数将x入栈，若入栈成功返回1，否则返回0。
int enqueue( stack s1, elemtp x )
{
if( top1==n && !Sempty(s2) ) // top1是栈s1的栈顶指针，是全局变量
{
// s1满、s2非空，这时s1不能再入栈
printf(“栈满”);
return(0);
}
if( top1==n && Sempty(s2) ) // 若s2为空，先将s1退栈,元素再压栈到s2
{
while( !Sempty(s1) )
POP( s1, x );
PUSH( s2, x );
}
PUSH( s1, x ); // x入栈，实现了队列元素的入队
return(1);
}
// s2是输出栈，本函数将s2栈顶元素退栈，实现队列元素的出队
void dequeue( stack s2, stack s1 )
{
if( !Sempty(s2) ) // 栈s2不空，则直接出队
{
POP( s2, x );
printf( “出队元素为”, x );
}
else if( Sempty(s1) ) // 处理s2空栈。若输入栈也为空，则判定队空
{
printf(“队列空”);
exit(0);
}
else // 先将栈s1倒入s2中，再作出队操作
{
while( !Sempty(s1) )
{
POP( s1, x );
PUSH( s2, x );
}
POP( s2, x ); // s2退栈相当队列出队
printf( “出队元素为”, x );
}
}
// 本函数判用栈s1和s2模拟的队列是否为空
int queue_empty()
{
if( Sempty(s1) && Sempty(s2) ) // 队列空
return(1);
else
return(0); //队列不空。
}
#include <stdlib.h>
#include <stdio.h>
typedef struct
{
char *base;
char *top;
int stack_size;
}stack;
void init_stack(stack *s)
{
s->base=(char *)malloc(50*sizeof(char));
if(!s->base)return;
s->top=s->base;
s->stack_size=50;
}
void push(stack *s,char e)
{
if(s->top-s->base>=s->stack_size)
{
s->base=(char *)realloc(s->base,(s->stack_size+50)*sizeof(char));
if(!s->base)return;
s->top=s->base+s->stack_size;
s->stack_size+=50;
}
*(s->top)=e;
s->top++;
}
void pop(stack *s,char *e)
{
s->top--;
*e=*(s->top);
}
int stack_empty(stack *s)
{
if(s->top==s->base)return 1;
return 0;
}
int queue_empty(stack *s1,stack *s2)
{
if(stack_empty(s1)&&stack_empty(s2))return 1;
return 0;
}
void dequeue(stack *s1,stack *s2,char *a) /*s1负责入队，s2负责出队*/
{ /*出队之前 */
char e; /*先把s1倒灌到s2里面*/
if(!queue_empty(s1,s2)) /*这样把最先入队的暴露在最外面*/
{
while(!stack_empty(s1))
{
pop(s1,&e);
push(s2,e);
}
pop(s2,a);
}
}
void enqueue(stack *s1,stack *s2,char a)
{
char e;
while(!stack_empty(s2))
{
pop(s2,&e);
push(s1,e);
}
push(s1,a);
}
main()
{
char e,*a="good good study day day up";
int i=0;
stack s1,s2;
init_stack(&s1);
init_stack(&s2);
while(a[i])
{
enqueue(&s1,&s2,a[i]);
i++;
}
while(!queue_empty(&s1,&s2))
{
dequeue(&s1,&s2,&e);
printf("%c",e);
}
getch();
}