1.不用辅助空间实现栈的逆序(利用函数的递归)
例如栈中元素1 2 3 4,逆序后栈中元素为4 3 2 1
int GetLastNumOfStack(stack<int>& s)// 得到栈顶的元素
{
int result = s.top();//取栈顶元素
s.pop();//出栈
if(s.empty()==true)
return result;//若是栈顶元素,则将该元素返回到上级函数
int last = GetLastNumOfStack(s);//接受返回的栈顶元素
s.push(result);//并将此时出栈的元素压入栈中(除栈顶元素外)
return last;//将栈顶元素返回到上级函数
}
void ReseriveStack(stack<int>& s)//利用递归实现栈元素逆序
{
if(s.empty()==true)
return;
int i = GetLastNumOfStack(s);//得到第一个栈底元素
ReseriveStack(s);//函数递归
s.push(i);//元素压栈
}
测试代码
int main()
{
stack<int> s;
s.push(1);
s.push(2);
s.push(3);
ReseriveStack(s);
return 0;
}
2.得到GetMin功能的栈
- 方法一:
#include<stdio.h>
#include<stack>
#include<iostream>
using namespace std;
#include<stack>
template<class T>
class Stack
{
public:
Stack()
{}
void Push(const T& data)
{
StackData.push(data);
if(StackMin.empty() || StackMin.top() > data)
StackMin.push(data);
else
StackMin.push(StackMin.top());//StackData的值和StackMin元素的个数相同
}
void Pop()
{
if(StackData.empty())
return;
StackData.pop();
StackMin.pop();
}
T GetMin()
{
return StackMin.top();
}
private:
stack<T> StackData;
stack<T> StackMin;
};
- 方法二:
#include<stack>
template<class T>
class Stack
{
public:
Stack()
{}
void Push(const T& data)
{
StackData.push(data);
if(StackMin.empty() || StackMin.top() > data)
StackMin.push(data);
}
void Pop()
{
if(StackData.empty())
return;
int value = StackData.top();
StackData.pop();
if(value == StackMin.top())
StackMin.pop();
}
T GetMin()
{
return StackMin.top();
}
private:
stack<T> StackData;
stack<T> StackMin;
};
测试代码:
void funtest()
{
Stack<int> s;
s.Push(4);
s.Push(1);
s.Push(3);
s.Push(2);
s.Push(5);
s.Pop();
int ret = s.GetMin();
}
int main()
{
funtest();
getchar();
return 0;
}
两种方法的比较:
两种方法的时间复杂度都相同,都为O(1),且空间复杂度都为O(N);区别是:方法一中StackData入栈的时候要浪费空间,但是弹出的时候节省时间,方法二中StackData入栈的时候要节省空间,但弹出时浪费时间。
3.由两个栈实现一个队列
template<class T>
class Queue
{
public:
Queue()
{}
void Push(const T& value)
{
StackPush.push(value);
}
void Pop()
{
if(StackPop.empty() && StackPush.empty())
return;
if(StackPop.empty())
{
while(!StackPush.empty())
{
int num = StackPush.top();
StackPop.push(num);
StackPush.pop();
}
}
StackPop.pop();
}
private:
stack<int> StackPush;
stack<int> StackPop;
};
测试代码:
int main()
{
Queue<int> q;
q.Push(1);
q.Push(2);
q.Push(3);
q.Push(4);
q.Pop();
getchar();
return 0;
}
4.用一个栈来实现另一个栈的排序,要求栈由栈顶到栈底从大到小
void SortStackByStack(stack<int>& stackData)
{
//由题意知,stackData由栈顶到栈底从大到小排序,则help由栈顶到栈底从小到大排序
stack<int> help;
if(stackData.empty())
return;
while(!stackData.empty())
{
int value = stackData.top();
stackData.pop();
if(help.empty() || value <= help.top())
help.push(value);
if(value > help.top())
{
while(!help.empty() && value > help.top())
{
int num = help.top();
help.pop();
stackData.push(num);
}
stackData.push(value);
}
}
while(!help.empty())
{
int ret = help.top();
help.pop();
stackData.push(ret);
}
}
测试代码:
void funtest()
{
stack<int> s;
s.push(6);
s.push(5);
s.push(4);
s.push(3);
s.push(2);
s.push(1);
SortStackByStack(s);
}
int main()
{
funtest();
getchar();
return 0;
}