栈与队列练习

不带头结点链队列

题目

假设以不带头结点的循环链表表示队列，并且只设一个指针指向队尾结点，但不设头指针。试设计相应的入队和出队的算法。

代码

入队

template <typename T>
void LinkQueue<T>::EnQueue(T x){
	Node<T> *p=new Node<T>;
	p->data=x;
	//注意处理空表情况
	if(rear==nullptr){
		rear=p;
		rear->next=p;
	}else{
		p->next=rear->next;
		rear->next=p;
		rear=p;
	}
}

出队

template <typename T>
T LinkQueue<T>::DeQueue(){
	if(rear==nullptr) throw"下溢";
	Node<T> *p=rear->next;
	T x=p->data;
	//别漏了删了之后为空表的情况！
	if(rear==p) rear=nullptr;
	else
		rear->next=p->next;
	delete p;
	return x;
}

顺序栈排序

题目

设顺序栈S中有2n个元素，从栈顶到栈底的元素依次为a₂ₙ，a₂ₙ₋₁，…，a₁，要求通过一个循环队列重新排列栈中元素，使得从栈顶到栈底的元素依次为a₂ₙ，a₂ₙ₋₂，…，a₂，a₂ₙ₋₁，a₂ₙ₋₃…，a₁，请设计算法实现该操作，要求空间复杂度和时间复杂度均为O(n)。

思路：

栈的特点：经过栈之后顺序会与入栈顺序相反
队列的特点：经过队列之后顺序仍保持与入队顺序相同

解题思路：
1.将所有元素出栈并进队
2.依次出队，如果是偶数则入队，如果是奇数则入栈
3.奇数出栈并入队
4.偶数出队并入栈
5.偶数出栈并入队
6.将所有元素出队并入栈即为所求

代码

#include <iostream>

using namespace std;
//顺序栈
const int StackSize = 100;
template<class T>
class SeqStack{
public:
    SeqStack();
    ~SeqStack();
    void Push(T x);
    T Pop();
    T Top();
    int Empty();
private:
    int top;
    T data[StackSize];
};
template<class T>
SeqStack<T>::SeqStack(){
    top=-1;
}
template<class T>
SeqStack<T>::~SeqStack(){

}
template<class T>
void SeqStack<T>::Push(T x){
    if(top==StackSize-1)  throw "上溢";
    data[++top]=x;
}
template<class T>
T SeqStack<T>::Pop(){
    if(top==-1) throw "下溢";
    T x=data[top--];
    return x;
}
template<class T>
T SeqStack<T>::Top(){
    return data[top];
}
template<class T>
int SeqStack<T>::Empty(){
    return top==-1?1:0;
}
//循环队列
const int QueueSize = 100;
template<class T>
class CirQueue{
public:
    CirQueue();
    ~CirQueue();
    void EnQueue(T x);
    T DeQueue();
    T GetHead();
    int Empty();
private:
    T data[QueueSize];
    int front,rear;
};
template<class T>
CirQueue<T>::CirQueue(){
    front=rear=QueueSize-1;
}
template<class T>
CirQueue<T>::~CirQueue(){

}
template<class T>
void CirQueue<T>::EnQueue(T x){
    if((rear+1)%QueueSize==front)   throw "上溢";
    rear=(rear+1)%QueueSize;
    data[rear]=x;
}
template<class T>
T CirQueue<T>::DeQueue(){
    if(rear==front) throw "下溢";
    front=(front+1)%QueueSize;
    return data[front];
}
template<class T>
T CirQueue<T>::GetHead(){
    if(rear==front) throw "下溢";
    return data[(front+1)%QueueSize];
}
template<class T>
int CirQueue<T>::Empty(){
    return rear==front?1:0;
}

int main()
{
    int n;
    cin>>n;
    SeqStack<int> ss;
    for(int i=1;i<=2*n;i++){
        ss.Push(i);
    }

    CirQueue<int> cq;
//1.全部出栈进队
    while(!ss.Empty()){
        int x=ss.Pop();
        cq.EnQueue(x);
    }
//2.出队，偶数入队，奇数入栈
    for(int i=0;i<2*n;i++){
        int x=cq.DeQueue();
        if(x%2==0)
            cq.EnQueue(x);
        else
            ss.Push(x);
    }
//3.奇数出栈入队
    while(!ss.Empty()){
        int x=ss.Pop();
        cq.EnQueue(x);
    }
//4.偶数出队入栈
    for(int i=0;i<n;i++){
        int x=cq.DeQueue();
        ss.Push(x);
    }
//5.偶数出栈入队
    while(!ss.Empty()){
        int x=ss.Pop();
        cq.EnQueue(x);
    }
//6.全部出队入栈
    while(!cq.Empty()){
        int x=cq.DeQueue();
        ss.Push(x);
    }
    return 0;
}

进制转换

题目

设计算法，把十进制整数转换为二至九进制之间的任一进制输出。

代码