数据结构面试之四——队列的常见操作
题注:《面试宝典》有相关习题,但思路相对不清晰,排版有错误,作者对此参考相关书籍和自己观点进行了重写,供大家参考。
四、队列的基本操作
1.用数组构造队列
队列即是满足先进先出的链表。用数组存储的话,同样需要满足队列头front出栈,队列末尾rear入栈。而对于数组来讲,rear和front可以代表数组头和尾。不能简单的固定rear和front的大小为maxSize和0,因为可能出现中间元素为空的现象。所以,对于数组队列来讲,可以想象成环式存储,因为每一次入队后rear+1,每一次出队后front+1。这就需要控制front和rear的大小,每一次修改只要满足front=(front+1)%maxSize,rear=(rear+1)%maxSize即可满足要求。
同样需要注意:入队操作前先判定队列是否已经满;出队操作前先判定队列是否为空。
template<typename Type>
class arrQueue
{
public:
arrQueue(intnSize=100);
~arrQueue();
arrQueue(constarrQueue<Type>& copyQueue);
arrQueue&operator=(const arrQueue<Type>& otherQueue);
voidinitializeQueue();
void destroyQueue();
bool isQueueEmpty();
bool isQueueFull();
void addQueue(constType& item);
void deQueue(Type&deletedItem);
private:
int maxSize;
int rear;
int front;
Type* list;
};
template<typename Type>
arrQueue<Type>::arrQueue(int nSize=100)
{
if(nSize < 0)
{
nSize = 100;
list = newType[nSize];
front = 0;
rear = 0;
maxSize = 100;
}
else
{
list = newType[nSize];
front = 0;
rear = 0;
maxSize =nSize;
}
}
template<typename Type>
arrQueue<Type>::~arrQueue()
{
if(!list)
{
delete[]list; //注意数组的删除,为delete []list;
list = NULL;
}
}
template<typename Type>
arrQueue<Type>::arrQueue(const arrQueue<Type>©Queue)
{
maxSize =copyQueue.maxSize;
front =copyQueue.front;
rear = copyQueue.rear;
list = newType[maxSize]; //注意需要自定义大小,容易出错.
for( int i = 0; i <rear; i++)
{
list[i] =copyQueue.list[i];
}
}
template<typename Type>
arrQueue<Type>& arrQueue<Type>::operator=(constarrQueue<Type>& otherQueue)
{
if(this ==&otherQueue)
{
cout <<"can't copy oneSelf!" << endl;
return *this;
}
else
{
if(maxSize !=otherQueue.maxSize)
{
cout<< "The Size of two Queue are not equal!" << endl;
return*this;
}
else
{
maxSize= otherQueue.maxSize;
front =otherQueue.front;
rear =otherQueue.rear;
for( inti = 0; i < rear; i++)
{
list[i]= otherQueue.list[i];
}//endfor
return*this;
}
}//end else
}
template<typename Type>
void arrQueue<Type>::initializeQueue()
{
destroyQueue();
}
template<typename Type>
void arrQueue<Type>::destroyQueue()
{
front = 0;
rear = 0;
}
//栈空的判定标志rear==front[初始]
template<typename Type>
bool arrQueue<Type>::isQueueEmpty()
{
return (rear ==front);
}
//空余1位作为判定位,可以把存储结构想象成环!
//注意栈满的判定:1.保证空间都被占用;
//2.保证rear的下一个位置=front即为满。
template<typename Type>
bool arrQueue<Type>::isQueueFull()
{
return((rear+1)%maxSize == front);
}
template<typename Type>
void arrQueue<Type>::addQueue(const Type& item)
{
if(!isQueueFull())
{
list[rear] =item;
rear =(rear+1)%maxSize;
cout << item<< " was added to Queue!" << endl;
}
else
{
cout <<"The Queue was already Full!" << endl;
}
}
template<typename Type>
void arrQueue<Type>::deQueue(Type& deletedItem)
{
if(!isQueueEmpty())
{
deletedItem =list[front];
front =(front+1)%maxSize; //注意此处的判定!
cout <<deletedItem << " was deleted from Queue!" << endl;
}
else
{
cout <<"The Queue was already Empty!" << endl;
}
}
2.队列采用链表链式存储结构
注意:1)此时的front和rear都变成了指针,front变成了头结点指针,而rear变成了尾节点的指针。2)此处的front和rear类似于链表操作中的first和last。3)入队实现主要在队列尾部实现,需要调整rear指针的指向;而出队操作主要在队头实现,需要调整front指针的指向。
template<typename Type>
struct nodeType
{
Type info;
nodeType* link;
};
template<typename Type>
class linkedQueue
{
public:
linkedQueue();
~linkedQueue();
linkedQueue(constlinkedQueue<Type>&);
linkedQueue&operator=(const linkedQueue<Type>&);
voidinitializeQueue();
void destroyQueue();
bool isQueueEmpty()const;
bool isQueueFull()const;
void addQueue(constType& item);
void deQueue(Type&poppedItem);
void nodeCount();
private:
nodeType<Type>*rear;
nodeType<Type>*front;
int count; //统计节点个数
};
template<typename Type>
linkedQueue<Type>::linkedQueue()
{
count = 0;
front = NULL;
rear = NULL;
}
template<typename Type>
linkedQueue<Type>::~linkedQueue()
{
while( front != NULL )
{
nodeType<Type>*tempNode = new nodeType<Type>;
tempNode =front;
front =front->link;
deletetempNode;
}
//注意rear的清空
rear = NULL;
}
template<typename Type>
linkedQueue<Type>::linkedQueue(constlinkedQueue<Type>& copyQueue)
{
if(copyQueue.front !=NULL)
{
nodeType<Type>*current;
nodeType<Type>*first;
nodeType<Type>*newNode;
front = newnodeType<Type>;
front->info= copyQueue.front->info; //此处的top不能直接用,内存报错!
front->link= copyQueue.front->link;
first =front; //first跟进当前链表...
current =copyQueue.front->link; //current跟进copy链表...
while( current!= NULL)
{
newNode= new nodeType<Type>;
newNode->link= current->link;
newNode->info= current->info;
first->link= newNode;
first =newNode;
current= current->link;
}//end while
rear = current;
count =copyQueue.count;
}//end if
else
{
front = NULL;
rear = NULL;
count = 0;
}
}
template<typename Type>
linkedQueue<Type>& linkedQueue<Type>::operator=(constlinkedQueue<Type>& otherQueue)
{
//1避免自身赋值
if(this ==&otherQueue)
{
cout <<"Can't copy oneself!" << endl;
return *this;
}
//2其他
else
{
if(front !=NULL)
{
destroyQueue();
}
if(otherQueue.front!= NULL)
{
nodeType<Type>*current;
nodeType<Type>*first;
nodeType<Type>*newNode;
front =new nodeType<Type>;
front->info= otherQueue.front->info;
front->link= otherQueue.front->link;
first =front; //first跟进当前链表...
current= otherQueue.front->link; //current跟进copy链表...
while(current != NULL)
{
newNode= new nodeType<Type>;
newNode->link= current->link;
newNode->info= current->info;
first->link= newNode;
first= newNode;
current= current->link;
}//endwhile
rear =current;
count =otherQueue.count;
}//end if
else
{
front =NULL;
rear =NULL;
count =0;
}
return *this;
}
}
template<typename Type>
void linkedQueue<Type>::initializeQueue()
{
destroyQueue();
}
template<typename Type>
void linkedQueue<Type>::destroyQueue()
{
count = 0;
//注意此处的销毁工作:需要循环判定!
while(front != NULL)
{
nodeType<Type>*temp = new nodeType<Type>;
temp = front;
front =front->link;
}
rear = NULL;
}
template<typename Type>
bool linkedQueue<Type>::isQueueEmpty() const
{
return (front ==NULL);
}
template<typename Type>
bool linkedQueue<Type>::isQueueFull() const //空间非固定,动态申请!
{
return false;
}
template<typename Type>
void linkedQueue<Type>::addQueue(const Type& item)
{
if(!isQueueFull())
{
nodeType<Type>*newNode = new nodeType<Type>;
newNode->info= item;
newNode->link= NULL;
if(front ==NULL)
{
front =newNode;
rear =newNode;
}
else
{
rear->link= newNode;
rear =newNode;
}
count++;
cout <<item << " was pushed!" << endl;
}
}
template<typename Type>
void linkedQueue<Type>::deQueue(Type& deletedItem)
{
if(!isQueueEmpty())
{
nodeType<Type>*temp = new nodeType<Type>;
temp = front;
deletedItem =front->info;
front =front->link;
count--;
cout <<deletedItem << " was popped!" << endl;
delete temp;
}
}
template<typename Type>
void linkedQueue<Type>::nodeCount()
{
cout <<"nodeCount = " << count << endl;
}
3.用栈实现队列
注意栈是先进后出,而用两个栈:栈1先进后出,栈2在栈1的基础上先进后出,就能实现了先进先出。
注意:入队addtoQueue要保证将元素放入到栈1中;而对于出队deQueue要保证将栈1的全部元素出栈pop,然后再全部入栈2,最后执行出栈2操作即可。
#include"linkedStack.h"
template<typename Type>
class stackedQueue
{
public:
stackedQueue();
~stackedQueue();
void addQueue(Type item);
void deQueue(Type deletedItem);
bool isQueueEmpty();
bool isQueueFull();
private:
nodeType<Type>* front;
nodeType<Type>* rear;
linkedStack<Type>* firstStack;
linkedStack<Type>* secondStack;
int nodeCnt; //记录节点个数
};
template<typename Type>
stackedQueue<Type>::stackedQueue()
{
front = NULL;
rear = NULL;
nodeCnt = 0;
firstStack = new linkedStack<Type>;
secondStack = new linkedStack<Type>;
}
template<typename Type>
stackedQueue<Type>::~stackedQueue()
{
while(front != NULL)
{
nodeType<Type>* temp;
temp = front;
front = front->link;
}
rear = NULL;
if(firstStack != NULL)
{
delete firstStack;
firstStack = NULL;
}
if(secondStack != NULL)
{
delete secondStack;
secondStack = NULL;
}
}
template<typename Type>
voidstackedQueue<Type>::addQueue(Type item)
{
if(!isQueueFull())
{
nodeCnt++;
firstStack->push(item); //单个入栈1
cout << item << " was added toQueue!" << endl;
}
}
template<typename Type>
voidstackedQueue<Type>::deQueue(Type deletedItem)
{
if(!isQueueEmpty())
{
while(!firstStack->isStackEmpty())
{
firstStack->pop(deletedItem); //全部出栈1
if(!firstStack->isStackFull())
{
secondStack->push(deletedItem); //全部入栈2
}
}
if(!secondStack->isStackEmpty())
{
secondStack->pop(deletedItem); //单个出栈2
}
cout << deletedItem << " was out ofQueue!" << endl;
nodeCnt--;
}
}
template<typename Type>
boolstackedQueue<Type>::isQueueEmpty()
{
return (nodeCnt == 0);
}
template<typename Type>
boolstackedQueue<Type>::isQueueFull()
{
return false;
}
第四节结束。