?? 歡迎大家來(lái)到貝蒂大講堂??

????養(yǎng)成好習(xí)慣，先贊后看哦~????

所屬專(zhuān)欄：數(shù)據(jù)結(jié)構(gòu)與算法
貝蒂的主頁(yè)：Betty’s blog

1. 雙向隊(duì)列的定義

**雙向隊(duì)列(double?ended queue)**是一種特殊的隊(duì)列，它允許在隊(duì)列的隊(duì)尾與隊(duì)頭插入與刪除元素。根據(jù)其定義，我們也可以理解為兩個(gè)棧在棧底相連。

1. 隊(duì)尾入隊(duì)

2. 隊(duì)首入隊(duì)

3. 隊(duì)尾出隊(duì)

4. 隊(duì)尾出隊(duì)

2. 雙向隊(duì)列的分類(lèi)

雙向隊(duì)列也是線性表的一種，所以也可以分別用鏈表與數(shù)組實(shí)現(xiàn)。基于鏈表實(shí)現(xiàn)：為了方便雙向隊(duì)列在尾部的插入與刪除操作，所以我們選用雙向鏈表?；跀?shù)組實(shí)現(xiàn)：與隊(duì)列實(shí)現(xiàn)類(lèi)似，需要用循環(huán)數(shù)組(原因參考隊(duì)列實(shí)現(xiàn))。

3. 雙向隊(duì)列的功能

1. 隊(duì)列的初始化。
2. 判斷隊(duì)列是否為空。。
3. 返回隊(duì)頭與隊(duì)尾的元素。
4. 返回隊(duì)列的大小。
5. 入隊(duì)與出隊(duì)。
6. 打印隊(duì)列的元素。
7. 銷(xiāo)毀隊(duì)列。

4. 雙向隊(duì)列的聲明

4.1. 鏈?zhǔn)疥?duì)

雙向隊(duì)列與普通隊(duì)列的聲明區(qū)別就在于雙向隊(duì)列是基于雙向鏈表的方式實(shí)現(xiàn)。

typedef int QDataType;
typedef struct DuListNode
{
	QDataType data;
	struct Node* prev;
	struct Node* next;
}DuListNode;

typedef struct Deque
{
	size_t size;
	DuListNode* front;
	DuListNode* rear;
}Deque;

4.2. 循環(huán)隊(duì)

循環(huán)隊(duì)列的實(shí)現(xiàn)方式與普通隊(duì)列差不多。

typedef int QDataType;
#define MAXSIZE 50  //定義元素的最大個(gè)數(shù)
typedef struct {
    QDataType *data;
    int front;  //頭指針
    int rear;   //尾指針
}Deque;

5. 隊(duì)列的初始化

5.1. 鏈?zhǔn)疥?duì)

void DequeInit(Deque* d)//初始化
{
	assert(d);
	d->front = NULL;
	d->rear = NULL;
	d->size = 0;
}

5.2. 循環(huán)隊(duì)

void DequeInit(Deque* d)//初始化
{
	d->data = (QDataType*)malloc(sizeof(QDataType )* MAXSIZE);
	if (d->data == NULL)
	{
		perror("malloc fail:");
		return;
	}
	d->front = 0;
	d->rear = 0;
}

5.3. 復(fù)雜度分析

• 時(shí)間復(fù)雜度：無(wú)論是鏈?zhǔn)疥?duì)還是循環(huán)隊(duì)列花費(fèi)時(shí)間都是一個(gè)常數(shù)，所以時(shí)間復(fù)雜度為O(1)。
• 空間復(fù)雜度：鏈?zhǔn)疥?duì)空間是一個(gè)固定大小，空間復(fù)雜度為O(1)。而需要開(kāi)辟整個(gè)隊(duì)列的大小，空間復(fù)雜度為O(N)。

6. 判斷隊(duì)列是否為空

6.1. 鏈?zhǔn)疥?duì)

bool DequeEmpty(Deque* d)//判斷是否為空
{
	assert(d);
	return (d->front == NULL) && (d->rear == NULL);
}

6.2. 循環(huán)隊(duì)

bool DequeEmpty(Deque* d)//判斷是否為空
{
	assert(d);
	return d->front == d->rear;
}

6.3. 復(fù)雜度分析

• 時(shí)間復(fù)雜度：無(wú)論是鏈?zhǔn)疥?duì)還是循環(huán)隊(duì)列花費(fèi)時(shí)間都是一個(gè)常數(shù)，所以時(shí)間復(fù)雜度為O(1)。
• 空間復(fù)雜度：無(wú)論是鏈?zhǔn)疥?duì)還是循環(huán)隊(duì)列花費(fèi)空間都是一個(gè)固定大小，所以空間復(fù)雜度為O(1)。

7. 判斷隊(duì)列是否為滿(mǎn)

7.1. 鏈?zhǔn)疥?duì)

鏈?zhǔn)疥?duì)并不需要判斷。

7.2. 循環(huán)隊(duì)

為什么要取模操作，可以參考一下上一篇普通隊(duì)列的實(shí)現(xiàn)，同下。

bool DequeFull(Deque* d)//判斷隊(duì)列是否滿(mǎn)
{
	assert(d);
	return (d->rear + 1) % MAXSIZE == d->front;
}

8. 返回隊(duì)頭與隊(duì)尾的元素

8.1. 鏈?zhǔn)疥?duì)

QDataType DequeFront(Deque* d)//獲取隊(duì)頭元素
{
	assert(d);
	assert(!DequeEmpty(d));
	return d->front->data;
}
QDataType DequeBack(Deque* d)//獲取隊(duì)尾元素
{
	assert(d);
	assert(!DequeEmpty(d));
	return d->rear->data;
}

8.2. 循環(huán)隊(duì)

QDataType DequeFront(Deque* d)//獲取隊(duì)頭元素
{
	assert(d);
	assert(!DequeEmpty(d));
	return d->data[d->front];
}
QDataType DequeBack(Deque* d)//獲取隊(duì)尾元素
{
	assert(d);
	assert(!DequeEmpty(d));
	return d->data[(d->rear-1+MAXSIZE)%MAXSIZE];
}

8.3. 復(fù)雜度分析

• 時(shí)間復(fù)雜度：無(wú)論是鏈?zhǔn)疥?duì)還是循環(huán)隊(duì)列花費(fèi)時(shí)間都是一個(gè)常數(shù)，所以時(shí)間復(fù)雜度為O(1)。
• 空間復(fù)雜度：無(wú)論是鏈?zhǔn)疥?duì)還是循環(huán)隊(duì)列花費(fèi)空間都是一個(gè)固定大小，所以空間復(fù)雜度為O(1)

9. 返回隊(duì)列的大小

9.1. 鏈?zhǔn)疥?duì)

size_t DequeSize(Deque* d)//隊(duì)列長(zhǎng)度
{
	return d->size;
}

9.2. 循環(huán)隊(duì)

size_t DequeSize(Deque* d)//獲取隊(duì)列長(zhǎng)度
{
	assert(d);
	return (d->rear - d->front + MAXSIZE) % MAXSIZE;
}

9.3. 復(fù)雜度分析

• 時(shí)間復(fù)雜度：無(wú)論是鏈?zhǔn)疥?duì)還是循環(huán)隊(duì)列花費(fèi)時(shí)間都是一個(gè)常數(shù)，所以時(shí)間復(fù)雜度為O(1)。
• 空間復(fù)雜度：無(wú)論是鏈?zhǔn)疥?duì)還是循環(huán)隊(duì)列花費(fèi)空間都是一個(gè)固定大小，所以空間復(fù)雜度為O(1)

10. 入隊(duì)

10.1. 鏈?zhǔn)疥?duì)

10.1.1. 隊(duì)頭入隊(duì)

void DequeFrontPush(Deque* d, QDataType x)//隊(duì)首入隊(duì)
{
	assert(d);
	DuListNode* newnode = (DuListNode*)malloc(sizeof(DuListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	if (d->front == NULL)
	{
		d->front = d->rear = newnode;
	}
	else
	{
		d->front->prev = newnode;
		newnode->next = d->front;
		d->front = newnode;
	}
    d->size++;
}

10.1.2. 隊(duì)尾入隊(duì)

void DequeRearPush(Deque* d, QDataType x)//隊(duì)尾入隊(duì)
{
	assert(d);
	DuListNode* newnode = (DuListNode*)malloc(sizeof(DuListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	if (d->front == NULL)
	{
		d->front = d->rear = newnode;
	}
	else
	{
		d->rear->next = newnode;
		newnode->prev = d->rear;
		d->rear = newnode;
	}
	d->size++;
}

10.2. 循環(huán)隊(duì)

入隊(duì)需要提前判斷隊(duì)列是否為滿(mǎn)。

10.2.1. 隊(duì)頭入隊(duì)

void DequeFrontPush(Deque* d, QDataType x)//隊(duì)首入隊(duì)
{
	assert(d);
	if (DequeFull(d))
	{
		printf("隊(duì)列已滿(mǎn)\n");
		return;
	}
	d->data[(d->front - 1 + MAXSIZE) % MAXSIZE]=x;
	d->front = (d->front - 1 + MAXSIZE) % MAXSIZE;
}

10.2.2. 隊(duì)尾入隊(duì)

void DequeRearPush(Deque* d, QDataType x)//隊(duì)尾入隊(duì)
{
	assert(d);
	if (DequeFull(d))
	{
		printf("隊(duì)列已滿(mǎn)\n");
		return;
	}
	d->data[d->rear] = x;
	d->rear = (d->rear + 1) % MAXSIZE;
}

10.3. 復(fù)雜度分析

• 時(shí)間復(fù)雜度：無(wú)論是鏈?zhǔn)疥?duì)還是循環(huán)隊(duì)列花費(fèi)時(shí)間都是一個(gè)常數(shù)，所以時(shí)間復(fù)雜度為O(1)。
• 空間復(fù)雜度：無(wú)論是鏈?zhǔn)疥?duì)還是循環(huán)隊(duì)列花費(fèi)空間都是一個(gè)固定大小，所以空間復(fù)雜度為O(1)

11. 出隊(duì)

11.1. 鏈?zhǔn)疥?duì)

出隊(duì)需要提前判斷隊(duì)列是否為空。

11.1.1. 隊(duì)頭出隊(duì)

void DequeFrontPop(Deque* d)//隊(duì)首出隊(duì)
{
	assert(d);
	assert(!DequeEmpty(d));
	//1.只有一個(gè)結(jié)點(diǎn)
	if (d->front == d->rear)
	{
		free(d->front);
		d->front = d->rear = NULL;
	}
	//2.有多個(gè)結(jié)點(diǎn)
	else
	{
		DuListNode* next = d->front->next;
		next->prev = NULL;
		d->front->next = NULL;
		free(d->front);
		d->front = next;
	}
	d->size--;
}

11.1.2. 隊(duì)尾出隊(duì)

void DequeRearPop(Deque* d)//隊(duì)尾出隊(duì)
{
	assert(d);
	assert(!DequeEmpty(d));
	//1.只有一個(gè)結(jié)點(diǎn)
	if (d->front == d->rear)
	{
		free(d->front);
		d->front = d->rear = NULL;
	}
	else
	{
		DuListNode* prev = d->rear->prev;
		prev->next = NULL;
		d->rear->prev = NULL;
		free(d->rear);
		d->rear = prev;
	}
    d->size--;
}

11.2. 循環(huán)隊(duì)

11.2.1. 隊(duì)頭出隊(duì)

void DequeFrontPop(Deque* d)//隊(duì)首出隊(duì)
{
	assert(d);
	assert(!DequeEmpty(d));
	d->front = (d->front + 1) % MAXSIZE;
}

11.2.2. 隊(duì)尾出隊(duì)

void DequeRearPop(Deque* d)//隊(duì)尾出隊(duì)
{
	assert(d);
	assert(!DequeEmpty(d));
	d->rear = (d->rear - 1+MAXSIZE) % MAXSIZE;
}

11.3. 復(fù)雜度分析

• 時(shí)間復(fù)雜度：無(wú)論是鏈?zhǔn)疥?duì)還是循環(huán)隊(duì)列花費(fèi)時(shí)間都是一個(gè)常數(shù)，所以時(shí)間復(fù)雜度為O(1)。
• 空間復(fù)雜度：無(wú)論是鏈?zhǔn)疥?duì)還是循環(huán)隊(duì)列花費(fèi)空間都是一個(gè)固定大小，所以空間復(fù)雜度為O(1)

12. 打印隊(duì)列元素

12.1. 鏈?zhǔn)疥?duì)

void DequePrint(Deque* d)//打印隊(duì)列元素
{
	assert(d);
	DuListNode* cur = d->front;
	DuListNode* tail = d->rear;
	printf("隊(duì)頭:");
	while (cur != tail->next)
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("隊(duì)尾\n");
}

12.2. 循環(huán)隊(duì)

void DequePrint(Deque* d)//打印隊(duì)列元素
{
	assert(d);
	int cur = d->front;
	printf("隊(duì)頭->");
	while (cur != d->rear)
	{
		printf("%d->", d->data[cur]);
		cur = (cur + 1) % MAXSIZE;
	}
	printf("隊(duì)尾\n");

}

12.3. 復(fù)雜度分析

• 時(shí)間復(fù)雜度：無(wú)論是鏈?zhǔn)疥?duì)還是循環(huán)隊(duì)列都需要遍歷這個(gè)隊(duì)列，所以時(shí)間復(fù)雜度為O(N)。
• 空間復(fù)雜度：無(wú)論是鏈?zhǔn)疥?duì)還是循環(huán)隊(duì)列花費(fèi)空間都是一個(gè)固定大小，所以空間復(fù)雜度為O(1)

13. 銷(xiāo)毀隊(duì)列

13.1. 鏈?zhǔn)疥?duì)

void DequeDestroy(Deque* d)//銷(xiāo)毀隊(duì)列
{
	assert(d);
	DuListNode* cur = d->front;
	while (cur)
	{
		DuListNode* del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
	d->front = d->rear = NULL;
}

13.2. 循環(huán)隊(duì)

void DequeDestroy(Deque* d)//銷(xiāo)毀隊(duì)列
{
	assert(d);
	free(d->data);
	d->data = NULL;
	d->front = d->rear = 0;
}

13.3. 復(fù)雜度分析

• 時(shí)間復(fù)雜度：無(wú)論是鏈?zhǔn)疥?duì)還是循環(huán)隊(duì)列花費(fèi)時(shí)間都是一個(gè)常數(shù)，所以時(shí)間復(fù)雜度為O(1)。
• 空間復(fù)雜度：無(wú)論是鏈?zhǔn)疥?duì)還是循環(huán)隊(duì)列花費(fèi)空間都是一個(gè)固定大小，所以空間復(fù)雜度為O(1)

14. 對(duì)比與應(yīng)用

14.1. 對(duì)比

雙向隊(duì)列的兩種實(shí)現(xiàn)方式的效果與普通隊(duì)列實(shí)現(xiàn)差不多，這里就不在一一贅述。

14.2. 應(yīng)用

雙向隊(duì)列兼?zhèn)潢?duì)列與棧的性質(zhì)，所以可以應(yīng)用于這兩種數(shù)據(jù)結(jié)構(gòu)的所有應(yīng)用場(chǎng)景。

此外它應(yīng)用于撤銷(xiāo)的一種情景：通常情況下，撤銷(xiāo)是以棧的方式實(shí)現(xiàn)，當(dāng)我們每次更改時(shí)就入棧，撤銷(xiāo)就出棧。但是我們知道系統(tǒng)給與棧的空間是有限的，我們不可能一直入棧。當(dāng)入棧超過(guò)一個(gè)限度時(shí)，我們就用過(guò)刪除棧底的數(shù)據(jù)，這時(shí)棧這個(gè)數(shù)據(jù)結(jié)構(gòu)就無(wú)法滿(mǎn)足需求。所以這時(shí)我們可以使用雙向隊(duì)列來(lái)實(shí)現(xiàn)。文章來(lái)源地址http://www.zghlxwxcb.cn/news/detail-845950.html

15. 完整代碼

15.1. 鏈?zhǔn)疥?duì)

15.1.1. Deque.h

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int QDataType;
typedef struct DuListNode
{
	QDataType data;
	struct Node* prev;
	struct Node* next;
}DuListNode;

typedef struct Deque
{
	size_t size;
	DuListNode* front;
	DuListNode* rear;
}Deque;
void DequeInit(Deque* d);//初始化
bool DequeEmpty(Deque* d);//判斷是否為空
QDataType DequeFront(Deque* d);//獲取隊(duì)頭元素
QDataType DequeBack(Deque* d);//獲取隊(duì)尾元素
size_t DequeSize(Deque* d);//獲取隊(duì)列長(zhǎng)度
void DequeFrontPush(Deque* d, QDataType x);//隊(duì)首入隊(duì)
void DequeRearPush(Deque* d, QDataType x);//隊(duì)尾入隊(duì)
void DequeFrontPop(Deque* d);//隊(duì)首出隊(duì)
void DequeRearPop(Deque* d);//隊(duì)尾出隊(duì)
void DequePrint(Deque* d);//打印隊(duì)列元素
void DequeDestroy(Deque* d);//銷(xiāo)毀隊(duì)列

15.1.2. Deque.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Deque.h"
void DequeInit(Deque* d)//初始化
{
	assert(d);
	d->front = NULL;
	d->rear = NULL;
	d->size = 0;
}
bool DequeEmpty(Deque* d)//判斷是否為空
{
	assert(d);
	return (d->front == NULL) && (d->rear == NULL);
}
QDataType DequeFront(Deque* d)//獲取隊(duì)頭元素
{
	assert(d);
	assert(!DequeEmpty(d));
	return d->front->data;
}
QDataType DequeBack(Deque* d)//獲取隊(duì)尾元素
{
	assert(d);
	assert(!DequeEmpty(d));
	return d->rear->data;
}
size_t DequeSize(Deque* d)//隊(duì)列長(zhǎng)度
{
	return d->size;
}
void DequeFrontPush(Deque* d, QDataType x)//隊(duì)首入隊(duì)
{
	assert(d);
	DuListNode* newnode = (DuListNode*)malloc(sizeof(DuListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	if (d->front == NULL)
	{
		d->front = d->rear = newnode;
	}
	else
	{
		d->front->prev = newnode;
		newnode->next = d->front;
		d->front = newnode;
	}
    d->size++;
}
void DequeRearPush(Deque* d, QDataType x)//隊(duì)尾入隊(duì)
{
	assert(d);
	DuListNode* newnode = (DuListNode*)malloc(sizeof(DuListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	if (d->front == NULL)
	{
		d->front = d->rear = newnode;
	}
	else
	{
		d->rear->next = newnode;
		newnode->prev = d->rear;
		d->rear = newnode;
	}
	d->size++;
}
void DequeFrontPop(Deque* d)//隊(duì)首出隊(duì)
{
	assert(d);
	assert(!DequeEmpty(d));
	//1.只有一個(gè)結(jié)點(diǎn)
	if (d->front == d->rear)
	{
		free(d->front);
		d->front = d->rear = NULL;
	}
	//2.有多個(gè)結(jié)點(diǎn)
	else
	{
		DuListNode* next = d->front->next;
		next->prev = NULL;
		d->front->next = NULL;
		free(d->front);
		d->front = next;
	}
	d->size--;
}
void DequeRearPop(Deque* d)//隊(duì)尾出隊(duì)
{
	assert(d);
	assert(!DequeEmpty(d));
	//1.只有一個(gè)結(jié)點(diǎn)
	if (d->front == d->rear)
	{
		free(d->front);
		d->front = d->rear = NULL;
	}
	else
	{
		DuListNode* prev = d->rear->prev;
		prev->next = NULL;
		d->rear->prev = NULL;
		free(d->rear);
		d->rear = prev;
	}
    d->size--;
}
void DequePrint(Deque* d)//打印隊(duì)列元素
{
	assert(d);
	DuListNode* cur = d->front;
	DuListNode* tail = d->rear;
	printf("隊(duì)頭:");
	while (cur != tail->next)
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("隊(duì)尾\n");
}
void DequeDestroy(Deque* d)//銷(xiāo)毀隊(duì)列
{
	assert(d);
	DuListNode* cur = d->front;
	while (cur)
	{
		DuListNode* del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
	d->front = d->rear = NULL;
}

15.2. 循環(huán)隊(duì)

15.2.1. Deque.h

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int QDataType;
#define MAXSIZE 50  //定義元素的最大個(gè)數(shù)
typedef struct {
    QDataType *data;
    int front;  //頭指針
    int rear;   //尾指針
}Deque;

void DequeInit(Deque* d);//初始化
bool DequeEmpty(Deque* d);//判斷是否為空
bool DequeFull(Deque* d);//判斷隊(duì)列是否滿(mǎn)
QDataType DequeFront(Deque* d);//獲取隊(duì)頭元素
QDataType DequeBack(Deque* d);//獲取隊(duì)尾元素
size_t DequeSize(Deque* d);//獲取隊(duì)列長(zhǎng)度
void DequeFrontPush(Deque* d, QDataType x);//隊(duì)首入隊(duì)
void DequeRearPush(Deque* d, QDataType x);//隊(duì)尾入隊(duì)
void DequeFrontPop(Deque* d);//隊(duì)首出隊(duì)
void DequeRearPop(Deque* d);//隊(duì)尾出隊(duì)
void DequePrint(Deque* d);//打印隊(duì)列元素
void DequeDestroy(Deque* d);//銷(xiāo)毀隊(duì)列

15.2.2. Deque.c

void DequeInit(Deque* d)//初始化
{
	d->data = (QDataType*)malloc(sizeof(QDataType )* MAXSIZE);
	if (d->data == NULL)
	{
		perror("malloc fail:");
		return;
	}
	d->front = 0;
	d->rear = 0;
}
bool DequeEmpty(Deque* d)//判斷是否為空
{
	assert(d);
	return d->front == d->rear;
}
bool DequeFull(Deque* d)//判斷隊(duì)列是否滿(mǎn)
{
	assert(d);
	return (d->rear + 1) % MAXSIZE == d->front;
}
QDataType DequeFront(Deque* d)//獲取隊(duì)頭元素
{
	assert(d);
	assert(!DequeEmpty(d));
	return d->data[d->front];
}
QDataType DequeBack(Deque* d)//獲取隊(duì)尾元素
{
	assert(d);
	assert(!DequeEmpty(d));
	return d->data[(d->rear-1+MAXSIZE)%MAXSIZE];
}
size_t DequeSize(Deque* d)//獲取隊(duì)列長(zhǎng)度
{
	assert(d);
	return (d->rear - d->front + MAXSIZE) % MAXSIZE;
}
void DequeFrontPush(Deque* d, QDataType x)//隊(duì)首入隊(duì)
{
	assert(d);
	if (DequeFull(d))
	{
		printf("隊(duì)列已滿(mǎn)\n");
		return;
	}
	d->data[(d->front - 1 + MAXSIZE) % MAXSIZE]=x;
	d->front = (d->front - 1 + MAXSIZE) % MAXSIZE;
}
void DequeRearPush(Deque* d, QDataType x)//隊(duì)尾入隊(duì)
{
	assert(d);
	if (DequeFull(d))
	{
		printf("隊(duì)列已滿(mǎn)\n");
		return;
	}
	d->data[d->rear] = x;
	d->rear = (d->rear + 1) % MAXSIZE;
}
void DequeFrontPop(Deque* d)//隊(duì)首出隊(duì)
{
	assert(d);
	assert(!DequeEmpty(d));
	d->front = (d->front + 1) % MAXSIZE;
}
void DequeRearPop(Deque* d)//隊(duì)尾出隊(duì)
{
	assert(d);
	assert(!DequeEmpty(d));
	d->rear = (d->rear - 1+MAXSIZE) % MAXSIZE;
}
void DequePrint(Deque* d)//打印隊(duì)列元素
{
	assert(d);
	int cur = d->front;
	printf("隊(duì)頭->");
	while (cur != d->rear)
	{
		printf("%d->", d->data[cur]);
		cur = (cur + 1) % MAXSIZE;
	}
	printf("隊(duì)尾\n");

}
void DequeDestroy(Deque* d)//銷(xiāo)毀隊(duì)列
{
	assert(d);
	free(d->data);
	d->data = NULL;
	d->front = d->rear = 0;
}

到了這里，關(guān)于探索數(shù)據(jù)結(jié)構(gòu)：特殊的雙向隊(duì)列的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！