隊的演算法
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();
}