基本数据结构-队列

队列：是一种操作受限的线性表，限制为只允许在表的一端进行插入，另一端删除

1.顺序队

队空：q->front == q->rear

队满：q->rear == MaxSize - 1

进队操作：先将rear + 1，再把元素放在rear位置

出队操作：将front + 1，然后取出front位置的元素

2.循环队：解决假溢出问题

将data数组的前端和尾端连在一起。形成一个循环数组，逻辑上看成一个环。

队空：q->front == q->rear

队满：(q->rear + 1) % maxsize == q->front

储存的元素最多：Maxsize - 1

注意：初始化时front和rear = 0；

计算队中元素个数

方法a : 在创建结构体时，创建一个count数据项;

方法b : int count = (s->rear - s->front + MaxSize) % MaxSize;

3.不含有rear指针的循环队列

队空：s->count == 0;

队满：s->count == MaxSize;

出队：s->front = (s->front + 1) % Maxsize;

进队：int rear = (s->front + s->count) % MaxSize; rear=(rear+1)%MaxSize;

4.队列的链式存储结构及其基本运算的实现

采用链式存储结构的队列称为链队

思路：创建两种结点 A节点：队列元素（data域 next域） B节点：链队节点（front域 rear域）

注意：插入是针对队尾结点操作的，删除是针对对头结点操作的。（插入和删除时要明确是哪一个结点。）

a.队空：q->rear == NULL（也可以为q->front == NULL) 注意：千万不要写q->rear == q->front 因为如果是一个节点的情况下，q->rear == q->front

b.队满：此情况几乎不存在

c.进队：新建一个A类型节点，存放元素，将节点P插入作为尾节点（p->next = NULL; q->rear->next = p; q->rear = p;)

d.出队：取出队首节点的data值并将其删除

注意：出队的时候要考虑三种情况：

a.没有结点(return false;)

b.只有一个节点(q->rear = q->front = NULL)

c.有两个或两个以上的节点(p = q->front; q->front = q->front->next; e = p->data; free(p))

5.不含头结点，只含有一个尾节点指针rear的单循环链表存储队列

结构体类型与链表的节点的类型相同。（即data域 next域）

注意：a.rear所指向的结点是队尾  rear->next所指向的结点是队头

  b.rear是一个LinkNode指针，本身无意义，（没有用malloc函数在堆区分配空间），rear储存着尾节点的地址。通过rear可以访问尾节点的信息。

a.队空的条件：rear == NULL

b.队满的条件：不考虑

c.入队的条件：新建一个结点用来存放元素，然后让p插入(p->next = rear->next;)，作为尾结点，让rear指向这个新的尾结点。（rear = p; ）

d.出队的操作：取出队头结点（rear所指向的后继结点---即为rear->next)的data值并将其删除。

注意：出队的时候要考虑三种情况：a.没有结点。b.只有一个结点。c.有两个或两个以上的结点。

6.双端队列

待补充...

1.顺序队

#include <iostream>

using namespace std;

#define MaxSize 100

typedef struct sQqueue

{

        int rear, front;

        int data[MaxSize];

};

void Initial(sQqueue *& s)

{

s = (sQqueue*)malloc(sizeof(sQqueue));

s->front = s->rear = -1;

}

void Distory(sQqueue*&s)

{

free(s);

}

bool enQuque(sQqueue*&s,int e)

{

if (s->rear == MaxSize - 1)

{

return false;

}

s->rear++;

s->data[s->rear] = e;

return true;

}

bool deQuque(sQqueue*&s,int&e)

{

if (s->rear == s->front)

{

return false;

}

s->front++;

e = s->data[s->front];

return true;

}

bool isEmpty(sQqueue* s)

{

return (s->front == s->rear);

}

bool disp(sQqueue*s)

{

if(s->front==s->rear)

return false;

int top = s->front + 1;

while (top != s->rear + 1)

{

cout << s->data[top]<<" ";

top++;

}

return true;

}

int main()

{

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

sQqueue* s;

Initial(s);

for (int i = 0; i < 10; i++)

{

enQuque(s, arr[i]);

}

disp(s);

return 0;

}

2.循环队：解决假溢出问题

#include <iostream>

using namespace std;

#define Maxsize 10

typedef struct circlequque

{

int data[Maxsize];

//int front, rear;

int front, rear, count;

};

//初始化

void Initial(circlequque*&s)

{

s = (circlequque*)malloc(sizeof(circlequque));

s->front=3;

s->rear = 3;

s->count = 0;

}

//进队

bool Enquque(circlequque*& s,int e)

{

/*if ((s->rear + 1) % Maxsize == s->front)

{

return false;

}*/

if (s->count == Maxsize)

{

return false;

}

s->rear = (s->rear + 1)%Maxsize;

s->data[s->rear] = e;

s->count++;

return true;

}

//出队

bool Dequque(circlequque*& s, int& e)

{

if (s->front == s->rear)

{

return false;

}

s->front = (s->front + 1) % Maxsize;

e = s->data[s->front];s->count--;

return true;

}

//销毁队列

void Distory(circlequque* s)

{

free(s);

}

//打印队列

void dispquque(circlequque* s)

{

if (s->count == 0)

{

return;

}

int top;

top = (s->front + 1) % Maxsize;

do

{

cout << s->data[top];

top = (top + 1) % Maxsize;

} while (top != (s->rear+ 1) % Maxsize);

}

int main()

{

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

circlequque* s;

Initial(s);

for (int i = 0; i < 10; i++)

{

Enquque(s, arr[i]);

}

dispquque(s);

return 0;

}

3.不含有rear指针的循环队列

#include <iostream>

using namespace std;

#define maxsize 10

typedef struct squque

{

int data[maxsize];

int front, count;

};

void initial(squque*& s)

{

s = (squque*)malloc(sizeof(squque));

if (s == NULL)

{

return;

}

//s->count = s->front = 0;

s->count = 0;

s->front = 4;

}

void enquque(squque*& s, int e)

{

if (s->count == maxsize)

{

return;

}

int rear = (s->front + s->count) % maxsize;

rear = (rear + 1) % maxsize;

s->count++;

s->data[rear] = e;

}

void dequque(squque*& s, int& e)

{

if (s->count == 0)

{

return;

}

s->front = (s->front + 1) % maxsize;

e = s->data[s->front];

s->count--;

}

void dispquque(squque* s)

{

if (s->count == 0)

{

return;

}

int top;

top = (s->front + 1) % maxsize;

do

{

cout << s->data[top];

top = (top + 1) % maxsize;

} while (top != (s->front + s->count + 1) % maxsize);

}

int main()

{

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

squque* s;

initial(s);

for (int i = 0; i < 10; i++)

{

enquque(s, arr[i]);

}

dispquque(s);

return 0;

}

4.队列的链式存储结构及其基本运算的实现

#include <iostream>

using namespace std;

typedef struct ElemNode

{

int data;//创建data域

ElemNode* next;

};

typedef struct QNode

{

ElemNode* front;

ElemNode* rear;

};

void Initial(QNode*&s)

{

s = (QNode*)malloc(sizeof(QNode));

s->front = s->rear = NULL;

}

void enQueue(QNode*&s,int e)

{

ElemNode* t = (ElemNode*)malloc(sizeof(ElemNode));

t->data = e;

//当该链队没有元素

if ( s->rear == NULL)

{

s->front = t;

s->rear = t;

t->next = NULL;

return;

}

//当该链队有元素

else {

s->rear->next = t;

s->rear = t;

t->next = NULL;

}

}

void deQuque(QNode*&s,int&e)

{

if (s->rear == NULL)

{

return;

}

ElemNode* p;

//当链队中只有一个元素

if (s->rear == s->front)

{

e = s->rear->data;

free(s->rear);

s->front = s->rear = NULL;

}

else

{

p = s->front;

while (p->next != s->rear)

{

p = p->next;

}

e = s->rear->data;

free(s->rear);

s->rear = p;

p->next = NULL;

}

}

void Disp(QNode*&s)

{

ElemNode* p;

p = s->front;

if (s->rear == NULL)

{

return;

}

while (p != NULL)

{

cout << p->data << " ";

p = p->next;

}

free(p);

return;

}

int main()

{

QNode* s;

int array[10] = { 1,2,3,4,5,6,7,8,9,10 };

Initial(s);

for (int i = 0; i < 10; i++)

{

enQueue(s, array[i]);

}

int element;

Disp(s);

deQuque(s, element);

cout << "\nelement = " << element << endl;

Disp(s);

return 0;

}

5.不含头结点，只含有一个尾节点指针rear的单循环链表存储队列

#include <iostream>

using namespace std;

typedef struct LinkNode

{

int data;

LinkNode* next;

};

void InitIal(LinkNode*&rear)

{

rear = NULL;

}

bool isEmpty(LinkNode*rear)

{

return rear == NULL;

}

//rear 是一个元素节点

bool enQueue(LinkNode* rear, int e)

{

LinkNode* t = (LinkNode*)malloc(sizeof(LinkNode));

if (rear == NULL)

{

t->data = e;

rear = t;

rear->next = rear;

return true;

}

else

{

t->data = e;

t->next = rear->next;

rear->next = t;

rear = t;

return true;

}

}

bool deQueue(LinkNode* rear, int& e)

{

if (rear == NULL)

{

return false;

 }

else if (rear->next == NULL)

{

e = rear->data;

rear = NULL;

return true;

}

else

{

e = rear->data;

LinkNode* s = rear->next;

rear->next= s->next;

free(s);

return true;

}

}

void Disp(LinkNode*rear)

{

if (rear == NULL)

{

return;

}

LinkNode* p = rear->next;

do

{

cout << p->data<<" ";

p = p->next;

} while (p != rear->next);

}

int main()

{

int array[10] = { 1,2,3,4,5,6,7,8,9,10 };

LinkNode* rear;

InitIal(rear);

for (int i = 0; i < 10; i++)

{

enQueue(rear, array[i]);

}

Disp(rear);

return 0;

}