队列第一篇

循环队列：
【1】
利用数组，内存早已分配好；
利用一个已知大小的数组和front,rear两个整型数来计算数值在循环队列的那个位置；
判满：
(q.rear+1)%maxsize==q.front；
判空：
q.rear==q.front；
入队：
q.rear=(q.rear+1)%maxsize；
q.data[q.rear]=e；
出队：
q.front=(q.front+1)%maxsize；
t=q.data[q.front]；
初始化：
q.rear=0;
q.front=q.rear ;

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
#define maxsize 50
struct squeue
{
    int data[maxsize];
    int front,rear;
};
void init(squeue &q)
{
    q.rear=0;
    q.front=q.rear;
}
int Empty(squeue &q)
{
    if(q.rear==q.front)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}
int inqueue(squeue &q,int e)
{
    if((q.rear+1)%maxsize==q.front)
    {
        return 0;
    }
    q.rear=(q.rear+1)%maxsize;
    q.data[q.rear]=e;
    return 1;
}
int dequeue(squeue &q,int &e)
{
    if(q.rear==q.front)
    {
        return 0;
    }
    else
    {
        q.front=(q.front+1)%maxsize;
        e=q.data[q.front];
        return 1;
    }
}
int length(squeue &q)
{
    int l;
    l=(q.rear-q.front)%maxsize;
    return l;
}
int get(squeue &q)
{
    int e;
    if(q.rear==q.front)
    {
        return 0;
    }
    else
    {
        e=q.data[q.front+1];
        return e;
    }
}
void destory(squeue &q)
{
    while(q.front!=q.rear)
    {
        free(&q.data[q.front]);
        q.front=(q.front+1)%maxsize;
    }
}
int main()
{
    squeue q;
    init(q);
    int e,w;
    while(cin>>e)
    {
        inqueue(q,e);
    }
    cout<<length(q)<<endl;
    cout<<get(q)<<endl;
    while(Empty(q))
    {
        dequeue(q,w);
        cout<<w<<endl;
    }
    destory(q);
}

链队：
[1]一个百度上的链队博客：
http://www.cnblogs.com/bhlsheji/p/5079977.html

[2]另一个：
照一个大佬打的，学一点其他的知识。
构造函数的作用：
初始化对象的数据成员。//感觉应该相当于写了一个初始化队的函数；
构造函数:
构造函数，就是与类（或结构体）同名的函数，它与普通函数的区别在于，它没有返回类型;
构造函数名必须与类名或结构体名一样，
有参构造函数：
class a
{
a(int p);
}
无参构造函数：
class a
{
a();
}
//在C++当中，结构体中可以有成员变量，可以有成员函数，可以从别的类继承，也可以被别的类继承，可以有虚函数。

#include<cstdio>
#include<cstdlib>
struct Node
{
    Node *next;
    int data;
};
struct Queue
{
    Node *_front,*rear; /// _front作为链表头指针 第一个节点就是队首元素
                        /// rear记录队尾 若_front==rear则队列为空
    Queue() /// 构造函数
    {
        _front=(Node*)malloc(sizeof(Node));
        _front->next=NULL;
        rear=_front;
    }
    void Push(int num);
    int Pop();
    int Front();
    int Empty();
    void Clear();
    void Show();
};
int main()
{
    Queue q;

    printf("-----------------------------\n");
    printf("选项1：元素进队        选项2：元素出队\n");
    printf("选项3：查看队首元素    选项4：检查队列是否为空\n");
    printf("选项5：清除队列元素    选项6：查看队列中元素\n");
    printf("-----------------------------\n");
    int choose;
    while(~scanf("%d",&choose))
    {
        if (choose<1||choose>6)
            continue;
        if (choose==1)
        {
            int num;
            printf("输入进队元素：");
            scanf("%d",&num);
            q.Push(num);
        }
        if (choose==2)
        {
            int t=q.Pop();
            printf("%d\n",t);
        }
        if (choose==3)
        {
            if (q._front==q.rear)
            {
                puts("Error!");
            }
            else
            {
                int FrontElem=q.Front();
                printf("FrontElem of the queue is %d\n",FrontElem);
            }
        }
        if (choose==4)
        {
            if (q.Empty())
                puts("Queue is empty.");
            else
                puts("Queue is not empty.");
        }
        if (choose==5)
        {
            q.Clear();
        }
        if (choose==6)
        {
            q.Show();
        }
        system("pause");
        system("cls");
        printf("-----------------------------\n");
        printf("选项1：元素进队        选项2：元素出队\n");
        printf("选项3：查看队首元素    选项4：检查队列是否为空\n");
        printf("选项5：清除队列元素    选项6：查看队列中元素\n");
        printf("-----------------------------\n");
    }
    return 0;
}
void Queue::Push(int num)/// 和链栈一样
{
    Node *p;
    p=(Node*)malloc(sizeof(Node));
    p->data=num;
    rear->next=p;
    p->next=NULL;
    rear=p; /// rear更新队尾元素
    return ;
}
int Queue::Pop()
{
    Node *p,*q;
    int t;
    p=_front;
    if (p->next==NULL)
    {
        rear=_front;
        puts("Error!");
        return 0;
    }
    q=p->next;
    p->next=q->next;
    t=q->data;
    free(q);
    if (p->next==NULL) /// 如果弹出队首元素后队列为空就要更新rear 否则Front函数会出错
        rear=_front;
    return t;
}
int Queue::Front()
{
    return _front->next->data;
}
int Queue::Empty()
{
    if (_front->next==NULL)
        return 1;
    else
        return 0;
}
void Queue::Clear()
{
    Node *p,*q;
    p=_front->next;
    while(p!=NULL)
    {
        q=p->next;
        free(p);
        p=q;
    }
    _front->next=NULL;
    rear=_front;
    return ;
}
void Queue::Show()
{
    Node *p;
    p=_front;
    printf("Front->");
    while(p->next!=NULL)
    {
        printf("%d->",p->next->data);
        p=p->next;
    }
    puts("NULL");
    return ;
}

注：
void Queue::pop();
::表示域操作符；
（以类做例子，结构体跟它一样）例如：
声明了一个类a，类a里声明了一个成员函数void e()【int p()】，但是没有在类的声明里给出e()的定义，那么在类外定义e(）的函数时，就要写成void a::e();【int a::p()】，表示e()这个函数是a的成员函数。