循环队列:
【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的成员函数。