使用单链表实现队列
1. 算法导论原题
10.2-3
Implement a queue by a singly linked list L. The operations ENQUEUE and DEQUEUE should still take O(1) time.
译:使用一个单链表实现一个队列。入队和出队的时间复杂度都应该是O(1)。
2. 使用单链表实现队列
我们假设链表是用头插法,那么1、2、3插进入链表,在链表中的顺序就变成了3、2、1。如果我们想出队,就必须找到链表尾元素出队。因为要保持出队的时间复杂度是O(1),那么插入操作后要保存第一次插入的结点,出队就可以直接将保存的插入后的结点出队即可,然后出队后还要找到第一次插入的结点的前一个结点,又因为这是单链表,需要遍历整个链表才能找到前一个结点,这显然是违反了时间复杂度为O(1)。
假设链表用尾插法,那么1、2、3插进链表,在链表中的顺序依然是1、2、3、如果我们想出队,只需要将头节点的下一个元素出队。为了保持插入的时间复杂度是O(1),不可能每次插入的时候都去遍历链表,因此需要保存插入后的新节点,插入的操作就在保存的新节点后面插入。因此入队和出队的时间复杂度是O(1),这种方法才是可行的。
3. 实现(C++代码)
//SinglyLink.h
#pragma once
#include <assert.h>
#include <stdio.h>
template<typename ElemType>
class Node
{
public:
Node(Node<ElemType>* pNext = NULL, ElemType* pData = NULL);
ElemType const& GetData() const;
void SetData(ElemType val) ;
Node<ElemType>* const& GetNext() const;
void SetNext(Node<ElemType>* val);
private:
ElemType* m_pData;
Node<ElemType>* m_pNext;
};
template<typename ElemType>
class SinglyLinkList
{
public:
SinglyLinkList();
unsigned int const& GetLength() const;
bool Insert(ElemType elem, unsigned int pos);
bool InsertByPosNode(ElemType elem, Node<ElemType>* posNode, Node<ElemType>** RetInsetNode = NULL);
bool Delete(unsigned int pos, ElemType* elem);
bool Search(unsigned int pos, ElemType* elem) const;
bool Visit(ElemType* elem, const unsigned int& pos) const;
bool Empty();
Node<ElemType>* HavaHeadNode();
private:
Node<ElemType>* m_pHeadNode;
unsigned int m_length;
};
//————————————————————————————————//Node类的实现
template<typename ElemType>
Node<ElemType>::Node(Node<ElemType>* pNext /*= NULL*/, ElemType* pData /*= NULL*/)
:m_pNext(pNext),m_pData(pData)
{
}
template<typename ElemType>
void Node<ElemType>::SetNext(Node<ElemType>* val)
{
m_pNext = val;
}
template<typename ElemType>
Node<ElemType>* const& Node<ElemType>::GetNext() const
{
return m_pNext;
}
template<typename ElemType>
void Node<ElemType>::SetData(ElemType val)
{
m_pData = val;
}
template<typename ElemType>
ElemType const& Node<ElemType>::GetData() const
{
return *m_pData;
}
//————————————————————————————————//SinglyLink类实现
template<typename ElemType>
SinglyLinkList<ElemType>::SinglyLinkList()
:m_pHeadNode(new Node<ElemType>()),m_length(0)
{
}
template<typename ElemType>
bool SinglyLinkList<ElemType>::InsertByPosNode(ElemType elem, Node<ElemType>* posNode, Node<ElemType>** RetInsetNode /*= NULL*/)
{
Node<ElemType>* insertNode = new Node<ElemType>(posNode->GetNext(),new ElemType(elem));
posNode->SetNext(insertNode);
++m_length;
*RetInsetNode = insertNode;
return true;
}
template<typename ElemType>
bool SinglyLinkList<ElemType>::Insert(ElemType elem, unsigned int pos)
{
if (pos > GetLength() || pos < 0)
{
assert(false && "Error: SinglyLink's insert pos is out of range!\n");
return false;
}
for(Node<ElemType>* pCurrentNode = m_pHeadNode; pCurrentNode != NULL; pCurrentNode = pCurrentNode->GetNext())
{
if (pos-- == 0)
{
Node<ElemType>* insertNode = new Node<ElemType>(pCurrentNode->GetNext(),new ElemType(elem));
pCurrentNode->SetNext(insertNode);
++m_length;
return true;
}
}
assert(false && "Error: SinglyLink Insert failed for unknow reason!");
return false;
}
template<typename ElemType>
bool SinglyLinkList<ElemType>::Delete(unsigned int pos, ElemType* elem)
{
if (pos >= GetLength() || pos < 0)
{
assert(false && "Error: SinglyLink's delete pos is out of range!\n");
}
for(Node<ElemType>* pCurrentNode = m_pHeadNode; pCurrentNode != NULL; pCurrentNode = pCurrentNode->GetNext())
{
if (pos-- == 0)
{
Node<ElemType>* deleteNode = pCurrentNode->GetNext();
pCurrentNode->SetNext(deleteNode->GetNext());
*elem = deleteNode->GetData();
delete deleteNode;
--m_length;
return true;
}
}
assert(false && "Error: SinglyLink pos delete failed for unknow reason!");
return false;
}
template<typename ElemType>
unsigned int const& SinglyLinkList<ElemType>::GetLength() const
{
return m_length;
}
template<typename ElemType>
bool SinglyLinkList<ElemType>::Search(unsigned int pos, ElemType* elem) const
{
if (pos >= GetLength() || pos < 0)
{
assert(false && "Error: SinglyLink's search pos is out of range!\n");
}
for(Node<ElemType>* pCurrentNode = m_pHeadNode; pCurrentNode != NULL; pCurrentNode = pCurrentNode->GetNext())
{
if (pos-- == 0 && (pCurrentNode->GetNext() != NULL) )
{
*elem = pCurrentNode->GetNext()->GetData();
return true;
}
}
return false;
}
template<typename ElemType>
bool SinglyLinkList<ElemType>::Visit(ElemType* elem, const unsigned int& pos) const
{
if (pos >= GetLength() || pos < 0)
{
return false;
}
return Search(pos,elem);
}
template<typename ElemType>
bool SinglyLinkList<ElemType>::Empty()
{
return !m_length;
}
template<typename ElemType>
Node<ElemType>* SinglyLinkList<ElemType>::HavaHeadNode()
{
return m_pHeadNode;
}
//QueueBySinglyLink.h
#pragma once
#include "SinglyLinkList.h"
template<typename ElemType>
class QueueBySinglyLink
{
public:
QueueBySinglyLink();
bool EnQueue(ElemType elem);
bool DeQueue(ElemType* elem);
bool Empty();
unsigned int GetLength() const;
bool Visit(ElemType* elem, const unsigned int& pos) const;
private:
SinglyLinkList<ElemType>* m_pSinglyLink;
Node<ElemType>* m_TopNode;
};
template<typename ElemType>
bool QueueBySinglyLink<ElemType>::Empty()
{
return m_pSinglyLink->Empty();
}
template<typename ElemType>
unsigned int QueueBySinglyLink<ElemType>::GetLength() const
{
return m_pSinglyLink->GetLength();
}
template<typename ElemType>
bool QueueBySinglyLink<ElemType>::DeQueue(ElemType* elem)
{
return m_pSinglyLink->Delete(0,elem);
}
template<typename ElemType>
bool QueueBySinglyLink<ElemType>::EnQueue(ElemType elem)
{
if (m_pSinglyLink->InsertByPosNode(elem,m_TopNode, &m_TopNode))
{
return true;
}
else
{
assert(false && "Error: QueueBySinglyLink Push failed for allocate node");
return false;
}
}
template<typename ElemType>
QueueBySinglyLink<ElemType>::QueueBySinglyLink()
: m_pSinglyLink(new SinglyLinkList<ElemType>()), m_TopNode(m_pSinglyLink->HavaHeadNode())
{
}
template<typename ElemType>
bool QueueBySinglyLink<ElemType>::Visit(ElemType* elem, const unsigned int& pos) const
{
return m_pSinglyLink->Visit(elem,pos);
}
//Util.h
#pragma once
namespace Util
{
template<typename T>
void PrintMemory(const T& dateStruct, unsigned int size)
{
cout << "PrintMemory: ";
for (int i = 0; i != size; i++)
{
ElemType tempElem;
dateStruct.Visit(&tempElem,i);
printf("%d ",tempElem);
}
printf("\n");
printf("\n");
}
}
//main.cpp
#include "QueueBySinglyLink.h"
#include "Util.h"
#include <iostream>
using namespace std;
typedef int ElemType;
int main()
{
QueueBySinglyLink<ElemType> testQueueBySinglyLink;
Util::PrintMemory(testQueueBySinglyLink,testQueueBySinglyLink.GetLength());
cout << (testQueueBySinglyLink.Empty() ? "Empty QueueBySinglyLink." : "Not Empty QueueBySinglyLink.") << endl;
for (int i = 1; i != 5; i++)
{
testQueueBySinglyLink.EnQueue(i);
cout << "\nPush:" << i << endl;
Util::PrintMemory(testQueueBySinglyLink,testQueueBySinglyLink.GetLength());
cout << (testQueueBySinglyLink.Empty() ? "Empty QueueBySinglyLink." : "Not Empty QueueBySinglyLink.") << endl;
}
for(int i = 1; i!= 5; i++)
{
int temp;
testQueueBySinglyLink.DeQueue(&temp);
cout << "\nPop:" << temp << endl;
Util::PrintMemory(testQueueBySinglyLink,testQueueBySinglyLink.GetLength());
cout << (testQueueBySinglyLink.Empty() ? "Empty QueueBySinglyLink." : "Not Empty QueueBySinglyLink.") << endl;
}
return 0;
}
4. 程序运行结果
PrintMemory:
Empty QueueBySinglyLink.Push:1
PrintMemory: 1
Not Empty QueueBySinglyLink.Push:2
PrintMemory: 1 2
Not Empty QueueBySinglyLink.Push:3
PrintMemory: 1 2 3
Not Empty QueueBySinglyLink.Push:4
PrintMemory: 1 2 3 4
Not Empty QueueBySinglyLink.Pop:1
PrintMemory: 2 3 4
Not Empty QueueBySinglyLink.Pop:2
PrintMemory: 3 4
Not Empty QueueBySinglyLink.Pop:3
PrintMemory: 4
Not Empty QueueBySinglyLink.Pop:4
PrintMemory:
Empty QueueBySinglyLink.