数据结构之线性结构---队列 顺序储存

一、队列的特点

队列是一种比较特殊的数据结构，它只允许在一端插入元素，而在另一段删除元素，队列也是一种先入先出的数据结构允许插入的一端叫做队尾，而允许删除的一端叫做队头。



向队列中插入元素：



向队列中删除元素：



在队列中我们为了记录队头和对位的位置通常会建立一个指针来记录队头和对队尾，即队头不一定是内存中下标为0的内存位置。这样可以在使用顺序储存的时候，不必再删除一个元之后移动全部的元素，而造成移动元素的的运算消耗。

二、队列的顺序储存实现

AL_QueueSeq.h代码

#ifndef AL_QUEUESEQ_INCLUDE
#define AL_QUEUESEQ_INCLUDE

#include <windows.h>
template <typename T>
class AL_QueueSeq
{
public:
static const DWORD QUEUESEQ_DEFAULTSIZE = 100;
static const DWORD QUEUEDEQ_MAXSIZE = 0xffffffff;
AL_QueueSeq(DWORD size = QUEUESEQ_DEFAULTSIZE);
~AL_QueueSeq();
//判断队列中元素是否为空
bool IsEmpty()const;
//获取到队列头部的第一个元素
bool Front(T&tTypeOut)const;
//获取到尾部的第一个元素
bool Back(T&tTypeOut)const;
//从队头弹出一个元素
bool Pop(T&tTypeOut);
//从队为插入一个元素
void Push(const T&tData);
//返回队列中的元素个数
DWORD Size()const;
//清空队列
void Clear();
private:
//内存的分配
void GetBuffer();

4000
//判断队列的内存空间是否出存完
bool IsFull()const;
//储存队列元素空间
T*    m_pElenents;
//最大元素个数
DWORD m_dwMaxSize;
//当前储存的元素个数
DWORD m_dwSize;
//队列头部元素
DWORD m_dwFront;
//尾部元素
DWORD m_dwRear;
};

template<typename T>
inline AL_QueueSeq<T>::AL_QueueSeq(DWORD size) :m_pElenents(NULL), m_dwMaxSize(size), m_dwSize(0x00), m_dwFront(0x00), m_dwRear(0x00)
{
if (m_dwMaxSize==00)
{
m_dwMaxSize = 1;
}

GetBuffer();
}

template<typename T>
inline AL_QueueSeq<T>::~AL_QueueSeq()
{
if (m_pElenents!=NULL)
{
delete[] m_pElenents;
m_pElenents = NULL;
}
}

template<typename T>
inline bool AL_QueueSeq<T>::IsEmpty() const
{
return (m_dwSize == 0x00) ? true : false;
}

template<typename T>
inline bool AL_QueueSeq<T>::Front(T & tTypeOut) const
{

if (IsEmpty()==true)
{
return false;
}

tTypeOut = m_pElenents[m_dwFront];
return true;
}

template<typename T>
inline bool AL_QueueSeq<T>::Back(T & tTypeOut) const
{
if (IsEmpty()==true)
{
return false;
}
tTypeOut = m_pElenents[m_dwRear];
}

template<typename T>
inline bool AL_QueueSeq<T>::Pop(T & tTypeOut)
{
if (IsEmpty()==true)
{
return false;
}
tTypeOut = m_pElenents[m_dwFront];
m_dwFront++;
m_dwSize--;
return true;
}

template<typename T>
inline void AL_QueueSeq<T>::Push(const T & tData)
{
//队列中元素储存已满
if (IsFull()==true)
{
//从新分配内存
GetBuffer();
}

//队列中没有元素
if (m_dwRear==0x00 && IsEmpty()==true)
{
m_dwRear = 0x00;
}
else
{
m_dwRear++;
}
m_pElenents[m_dwRear] = tData;
m_dwSize++;
}

template<typename T>
inline DWORD AL_QueueSeq<T>::Size() const
{
return m_dwSize;
}

template<typename T>
inline void AL_QueueSeq<T>::Clear()
{
m_dwSize = 0x00;
m_dwFront = 0x00;
m_dwRear = 0x00;
}

template<typename T>
inline void AL_QueueSeq<T>::GetBuffer()
{
//队列还没有储存满
if (IsFull()==false&&m_pElenents!=NULL)
{
return;
}
//还没有为队列分配内存
if (m_pElenents==NULL)
{
if (m_dwMaxSize>0)
{
m_pElenents = new T[m_dwMaxSize];
}
return;
}

//队列储存满了
T*pLastPyte = NULL;
pLastPyte = m_pElenents;
//当内存已经到了最大值
if (m_dwMaxSize==QUEUEDEQ_MAXSIZE)
{
return;
}

if (m_dwMaxSize>QUEUEDEQ_MAXSIZE/2)
{
m_dwMaxSize = QUEUEDEQ_MAXSIZE;
}
else {
m_dwMaxSize *= 2;
}

if (m_dwMaxSize>0)
{
m_pElenents = new T[m_dwMaxSize];
}

for (DWORD dwCopy=0x00;dwCopy<Size();dwCopy++)
{
m_pElenents[dwCopy] = pLastPyte[dwCopy+m_dwFront];
}

m_dwFront = 0x00;
m_dwRear = Size() - 1;
delete[] pLastPyte;
pLastPyte = NULL;
}

template<typename T>
inline bool AL_QueueSeq<T>::IsFull() const
{
return (m_dwMaxSize <= m_dwFront + Size()) ? true : false;
}

#endif

测试代码：

void QueueSeqTest()
{
AL_QueueSeq<DWORD> clQueueSwq;
bool bEmpty = clQueueSwq.IsEmpty();
std::cout << bEmpty << std::endl;

DWORD dwSize = clQueueSwq.Size();
std::cout << dwSize << std::endl;

clQueueSwq.Push(123);
clQueueSwq.Push(456);
clQueueSwq.Push(789);

DWORD length = clQueueSwq.Size();
std::cout << length << std::endl;
DWORD den;
clQueueSwq.Back(den);
DWORD tan;
clQueueSwq.Front(tan);
DWORD mei;
clQueueSwq.Pop(mei);

length = clQueueSwq.Size();

std::cout << den << "  " << tan << "  " << mei << "  " << std::endl;
clQueueSwq.Front(den);
std::cout << den << "  " << length << std::endl;
}

int main(int argc, char *argv[])
{
QueueSeqTest();
getchar();
return 0;
}

运行结果：