2. 程式人生 > >C++迴圈佇列的陣列實現

C++迴圈佇列的陣列實現

阿新 • • 發佈：2018-12-10

迴圈佇列的陣列實現

---------------------------------------------------------------------------- 博主這篇給大家帶來迴圈佇列的陣列實現。廢話不多說，我們開始工作。

相信大家對陣列並不陌生，而且佇列的陣列實現其實就是普通陣列加上隊頭隊尾兩個指標來進行佇列結構的控制。 而相比普通的陣列佇列，迴圈佇列的優點在於空間上的優化使用。普通佇列的隊頭資料出列的時候，這個資料所在的位置我們就不會再用了，久而久之，在空間儲存上就會造成浪費。而迴圈佇列就可以避免這個問題，並只有在滿列時才會進行擴容，來存放新的資料。 雖然對於空間儲存是優化，但對於我們來說，就要稍微用點腦jin去重新寫一下演算法來實現它。

博主接下來會把一些重要的功能給大家詳細講解，其他的如建構函式，解構函式，會在後面一起貼出來，大家到時候去看。 這是迴圈佇列的變數和函式，博主先給大家，後面我們要用到

template <class T>
class SeqQueue              //為了優化結構，將佇列改為迴圈佇列
{
private:
	T* dataArray;     //佇列陣列
	int front;        //佇列的頭指標
	int rear;        //佇列的尾指標
	int maxsize;      //佇列容量
	char Full_Empty;   //如果滿，Full_Empty='f',如果空Full_Empty='e',佇列不滿標識'b'
	void OverFlowProcess();       //溢位處理
public:
	SeqQueue(int size);       //建構函式，大小為size
	~SeqQueue();              //解構函式
	bool InQueue(const T& x);   //資料x入列
	bool OutQueue(T& outValue);      //隊頭資料出列，並將其值賦給outValue
	bool GetFront(T& frontValue);     //讀取隊頭資料值
	int GetSize()const;             //計算佇列使用長度
	void MakeEmpty();               //清空佇列
};

----------------------------------------------------------------------------------- 注意，從上圖我們可以看出，當rear==front的時候，我們是無法判斷它是空還是滿，因此，我們用了一個標識： char Full_Empty; //如果滿，Full_Empty=‘f’,如果空Full_Empty=‘e’,佇列不滿標識’b’

Full_Empty用來方便我們判斷佇列的狀態。 而且一開始我們的隊頭和隊尾是指向下標為[0]的，即定義

int rear=0;
int front=0;

然後我們要進行資料的入列：

template <class T>
void SeqQueue<T>::InQueue(const T& x)
{
	if (rear == front)          //如果佇列為空或者滿
	{
		if (Full_Empty == 'f')                //如果為滿佇列
		{
			OverFlowProcess();
			dataArray[rear] = x;
			rear = (rear + 1) % maxsize;
			Full_Empty = 'b';
		}
		else                                   //如果為空
		{
			dataArray[rear] = x;
			rear = (rear + 1) % maxsize;
			if (rear == front)                       //考慮到rear=front=0;maxsize=1;的情況
			{
				Full_Empty = 'f';
			}
			else
			{
				Full_Empty = 'b';
			}
		}
	}
	else                                       //如果佇列不為空列也不為滿列
	{
		dataArray[rear] = x;
		rear = (rear + 1) % maxsize;
		if (rear == front)
		{
			Full_Empty = 'f';
		}
	}
}

--------------------------------------------------------------------------------------

溢位處理，進行擴容

OverFlowProcess() 在進行擴容的時候我們已經判斷為滿列。但是，根據其滿列位置的不同，我們也需要分成兩種情況：rear=0以及rear!=0 為什麼要這樣分呢，是因為在進行資料拷貝的時候，如果rear=0，此時front也是0，我們就可以直接從front拷貝到maxsize-1,而不會出現漏掉資料的情況。 如果rear!=0,我們就要分兩部分來進行拷貝，一部分是從front到maxsize-1。另一部分是從0到rear-1。 在這裡插入圖片描述 這時候進行擴容的時候要注意，我們要先將原陣列的內容拷貝到新陣列中，並且，front的位置是改變的，變為front+擴容的大小。

template <class T>
void SeqQueue<T>::OverFlowProcess()
{
	T* newArray = new T[maxsize + Increasement];
	if (newArray == NULL)
	{
		cerr << "儲存分配失敗" << endl;
		exit(1);
	}
	if (rear - 1 < 0)
	{
		for (int i = front; i < maxsize; i++)
		{
			newArray[i] = dataArray[i];               //拷貝到新陣列
		}
		maxsize = maxsize + Increasement;
		for (int i = maxsize - 1; i >= (front + Increasement); i--)
		{
			newArray[i] = newArray[i - Increasement];
		}
		front = front + Increasement;
		delete[]dataArray;
		dataArray = newArray;
	}
	else
	{
		for (int i = front; i < maxsize; i++)
		{
			newArray[i] = dataArray[i];               //拷貝到新陣列
		}
		for (int i = 0; i < rear; i++)
		{
			newArray[i] = dataArray[i];
		}
		maxsize = maxsize + Increasement;
		for (int i = maxsize - 1; i >= (front + Increasement); i--)
		{
			newArray[i] = newArray[i - Increasement];
		}
		front = front + Increasement;
		delete[]dataArray;
		dataArray = newArray;
	}
}

--------------------------------------------------------------------------------------

出列函式

出列函式我們則分成兩部分： ①，佇列為空，我們返回false，說明為空佇列 ②，佇列不為空，即滿列和介於滿列和空列直接的狀態，出資料， front=(front+1)%maxsize

template <class T>
bool SeqQueue<T>::OutQueue(T& outValue)
{
	if (rear==front)
	{
		if (Full_Empty == 'e')         //如果為空
		{
			return false;
		}
		else                          //如果為滿
		{
			outValue = dataArray[front];
			front = (front + 1) % maxsize;
			if (front == rear)
			{
				Full_Empty = 'e';               //考慮到rear=front=0;maxsize=1;的情況
			}
			else
			{
				Full_Empty = 'b';
			}
			return true;
		}
	}
	else                             //不為空也不為滿
	{
		outValue = dataArray[front];
		front = (front + 1) % maxsize;
		if (front == rear)
		{
			Full_Empty = 'e';
		}
		return true;
	}
}

-------------------------------------------------------------------------------------- 其他函式博主就不再介紹了，比較簡單，博主把完整版程式碼貼在下面，大家可以參考：

#ifndef SEQQUEUE_H
#define SEQQUEUE_H
#include <stdlib.h>
#include <iostream>
using namespace std;
const int Increasement = 1;

template <class T>
class SeqQueue              //為了優化結構，將佇列改為迴圈佇列
{
private:
	T* dataArray;     //佇列陣列
	int front;        //佇列的頭指標
	int rear;        //佇列的尾指標
	int maxsize;      //佇列容量
	char Full_Empty;   //如果滿，Full_Empty='f',如果空Full_Empty='e',佇列不滿標識'b'
	void OverFlowProcess();       //溢位處理
public:
	SeqQueue(int size);       //建構函式，大小為size
	~SeqQueue();              //解構函式
	void InQueue(const T& x);   //資料x入列
	bool OutQueue(T& outValue);      //隊頭資料出列，並將其值賦給outValue
	bool GetFront(T& frontValue);     //讀取隊頭資料值
	int GetSize()const;             //計算佇列使用長度
	void MakeEmpty();               //清空佇列

	void output();
};
#endif // !SEQQUEUE_H

#include "seqqueue.h"

template <class T>
SeqQueue<T>::SeqQueue(int size)
{
	maxsize = size;
	dataArray = new T[maxsize];           //建立動態陣列
	if(dataArray==NULL)
	{ 
		cerr << "儲存分配失敗" << endl;
		exit(1);
	}
	front = rear = 0;                //隊頭隊尾指標初始化
	Full_Empty = 'e';                 //佇列為空
}
template <class T>
void SeqQueue<T>::OverFlowProcess()
{
	T* newArray = new T[maxsize + Increasement];
	if (newArray == NULL)
	{
		cerr << "儲存分配失敗" << endl;
		exit(1);
	}
	if (rear - 1 < 0)
	{
		for (int i = front; i < maxsize; i++)
		{
			newArray[i] = dataArray[i];               //拷貝到新陣列
		}
		maxsize = maxsize + Increasement;
		for (int i = maxsize - 1; i >= (front + Increasement); i--)
		{
			newArray[i] = newArray[i - Increasement];
		}
		front = front + Increasement;
		delete[]dataArray;
		dataArray = newArray;
	}
	else
	{
		for (int i = front; i < maxsize; i++)
		{
			newArray[i] = dataArray[i];               //拷貝到新陣列
		}
		for (int i = 0; i < rear; i++)
		{
			newArray[i] = dataArray[i];
		}
		maxsize = maxsize + Increasement;
		for (int i = maxsize - 1; i >= (front + Increasement); i--)
		{
			newArray[i] = newArray[i - Increasement];
		}
		front = front + Increasement;
		delete[]dataArray;
		dataArray = newArray;
	}
}
template <class T>
void SeqQueue<T>::InQueue(const T& x)
{
	if (rear == front)          //如果佇列為空或者滿
	{
		if (Full_Empty == 'f')                //如果為滿佇列
		{
			OverFlowProcess();
			dataArray[rear] = x;
			rear = (rear + 1) % maxsize;
			Full_Empty = 'b';
		}
		else
		{
			dataArray[rear] = x;
			rear = (rear + 1) % maxsize;
			if (rear == front)                       //考慮到rear=front=0;maxsize=1;的情況
			{
				Full_Empty = 'f';
			}
			else
			{
				Full_Empty = 'b';
			}
		}
	}
	else                                       //如果佇列不為空列也不為滿列
	{
		dataArray[rear] = x;
		rear = (rear + 1) % maxsize;
		if (rear == front)
		{
			Full_Empty = 'f';
		}
	}
}
template <class T>
bool SeqQueue<T>::OutQueue(T& outValue)
{
	if (rear==front)
	{
		if (Full_Empty == 'e')         //如果為空
		{
			return false;
		}
		else                          //如果為滿
		{
			outValue = dataArray[front];
			front = (front + 1) % maxsize;
			if (front == rear)
			{
				Full_Empty = 'e';               //考慮到rear=front=0;maxsize=1;的情況
			}
			else
			{
				Full_Empty = 'b';
			}
			return true;
		}
	}
	else                             //不為空也不為滿
	{
		outValue = dataArray[front];
		front = (front + 1) % maxsize;
		if (front == rear)
		{
			Full_Empty = 'e';
		}
		return true;
	}
}
template <class T>
bool SeqQueue<T>::GetFront(T& frontValue)
{
	if (Full_Empty=='e')
	{
		return false;
	}
	else
	{
		frontValue = dataArray[front];
		return true;
	}
}
template <class T>
int SeqQueue<T>::GetSize()const
{
	if (Full_Empty == 'e')
	{
		return 0;
	}
	else
	{
		if (Full_Empty == 'b')
		{
			if (rear < front)
			{
				return (maxsize - front + rear);
			}
			return (rear - front);
		}
		if (Full_Empty == 'f')
		{
			return maxsize;
		}
	}
}
template <class T>
void SeqQueue<T>::MakeEmpty()
{
	rear = 0;
	front = 0;
}
template <class T>
SeqQueue<T>::~SeqQueue()
{
	delete[]dataArray;
}

template <class T>
void SeqQueue<T>::output()
{
	if (Full_Empty == 'e')
	{
		cout << "nothing" << endl;
	}
	else
	{
		for (int i = 0; i < maxsize; i++)
		{
			cout << dataArray[i] << endl;
		}
	}
}

相關推薦

C++迴圈佇列的陣列實現

迴圈佇列的陣列實現 ---------------------------------------------------------------------------- 博主這篇給大家帶來迴圈佇列的陣列實現。廢話不多說，我們開始工作。 相信大家對陣列並不陌生

C++ 迴圈佇列基本演算法實現

C++ 迴圈佇列基本演算法實現 #ifndef CircleQueue_h #define CircleQueue_h const int QueueSize = 1000; template <class T> class CircleQueue { public: Circl

筆記七：基於陣列的迴圈佇列的實現

定義：佇列也是一種線性表。其特點是佇列的插入與刪除在兩端進行，是一個先進先出（FIFO）的線性表。插入元素的一端叫隊尾，刪除元素的一端叫隊首。 三種表現形式： 1、 公式1： location（i）=i ——佇列第i個元素對映到陣列中，即為下

C 迴圈佇列實現

一個迴圈佇列的C語言實現，資料型別Queue定義如下，注意在 typedef struct{...}Queue; 中Queue為資料型別，而在struct {...}Queue; 中Queue為一個變數

迴圈佇列的實現(Queue, C++版)

/* Queue.h */#ifndef __QUEUE_H__#define __QUEUE_H__ #include <iostream.h> extern "C" { void exit(int); } const int nDefaultQueueSize

C語言資料結構-順序佇列-陣列實現

#include <stdio.h> #include <stdlib.h> typedef struct SQueue{ int * data; int front,rear; int maxSize; } SQueue;

java迴圈佇列的實現

原始碼的github地址,可以下載到本地執行 package impl; import Interface.IQueue; /** * 迴圈佇列 * <p> * 注意：判空和判滿的兩種情況： * 情況1.另設一個標識位區別佇列是空還是滿 * 情況2.少用一個

C++迴圈佇列

佇列如果使用鏈式儲存結構則很容易實現，但是佇列一般用於對大量資料進行頻繁的入隊和出隊操作，若採用鏈式儲存結構，則要頻繁對記憶體進行分配和去配操作，開銷很大，效率很低，因此如果要頻繁的入隊或出隊操作時，鏈式結構是不合適的，而採用順序儲存結構的迴圈佇列則很好的解決了這個問題。 MyQueue.h

【資料結構】迴圈佇列的實現

#include<stdio.h> #include<stdlib.h> #include<string.h> #include<time.h> #define TURE 1 #define FALSE 0 #de

迴圈佇列的實現及操作

普通的順序佇列實現有弊端（P71），用迴圈佇列實現用來解決這一弊端，同時迴圈佇列實現需要空出一個空間來，依次來區分隊滿和隊空。 他的指標是不是真正的指標變數，而是int型的，用來記錄陣列下標，起到了指標的作用。因為只有這樣才能實現取模迴圈 注意：迴圈佇列的尾指標始終指Re

LeetCode迴圈佇列的實現,python

寫了好久終於把邏輯理順了，刪刪減減的註釋沒寫多少。小白很欣慰 class MyCircularQueue(object): # 設定定義傳進來的引數K，也就是佇列最大值，然後頭指標，尾指標，建立一個內部都為空且最大為K+1的列表 def __init__(self, k):

C++ 棧 （陣列實現）

上一篇用連結串列實現了stack，這篇我們採用陣列來儲存資料，陣列更容易理解，直接貼程式碼 第一、程式碼實現 1 #pragma once 2 #include <iostream> 3 using namespace std; 4 template <

LeetCode迴圈佇列的實現

寫了好久終於把邏輯理順了，刪刪減減的註釋沒寫多少。不過作為新手還是很欣慰 class MyCircularQueue(object): # 設定定義傳進來的引數K，也就是佇列最大值，然後頭指標，尾指標，建立一個內部都為空且最大為K+1的列表 def __init__(se

c語言佇列的實現

typedef int QElemType; typedef struct QNode //節點結構{ QElemType data; struct QNode *next;}QNode,*QueuePtr; typedef struct Link_queue//佇列的連結串列結構{ QueuePtr f

資料結構 迴圈佇列的實現

一、迴圈佇列的實現由於順序佇列的實現可能會造成假溢位，這裡引入一個迴圈佇列，當然，這裡你要知道資料在佇列中的最大規模，否則迴圈佇列慢之後想拓展就會變得非常麻煩！要求：實驗七、實現迴圈佇列各種基本運算的演算法1 實驗目的本實驗是要實現迴圈佇列的各種基本運算，通過該實驗更深刻地理

迴圈佇列 程式碼實現（FIFO）

1.概念     為充分利用向量空間，克服順序儲存結構的"假溢位"現象的方法是：將向量空間想象為一個首尾相接的圓環，並稱這種向量為迴圈向量。儲存在其中的佇列稱為迴圈佇列（Circular Queue）。這種迴圈佇列可以以單鏈表的方式來在實際程式設計應用中來實現。     迴

資料機構(10)--順序迴圈佇列的實現及相關操作

參考書籍：資料結構（C語言版）嚴蔚敏吳偉民編著清華大學出版社 1.順序佇列 順序佇列的型別定義如下： #define  maxsize 100/*佇列的最大容量*/ typedef char QElemtype; struct  Queue  {   QElemtype d

python3佇列及迴圈佇列基本實現

class Queue(object):# 定義佇列類 為什麼加入object def __init__(self,size): self.size = size #定義佇列長度

Javascript資料結構與演算法--佇列(順序佇列、優先佇列、迴圈佇列)的實現與用法

前言 佇列和棧非常類似，前面已經講過了棧的實現與用法，現在我們來說說佇列。 佇列介紹 佇列遵循FIFO（First In First Out，先進先出）原則的一組有序的項。 佇列是一種特殊的線性表，特殊之處在於它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作，和棧一樣，佇列是

迴圈佇列的實現

需求描述：實現一個固定長度的字元快取管理結構，實現字串的寫入和讀出。 1）佇列加資料，向cb尾追加長為length的字串，存在putting中； 當緩衝剩餘空間remain<length時，追加長為remain的字串，函式返回實際有效存放到緩衝中的字串； 2）佇列取