STL-关于栈和队列的面试题

题目分别为：

1.实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O(1)。

2.使用两个栈实现一个队列。

3.使用两个队列实现一个栈。

4.判断元素出栈、入栈顺序的合法性。如：入栈的序列（1, 2, 3, 4, 5），出栈序列为（4, 5, 3, 2, 1）是合法序列，入栈的序列（1, 2, 3, 4, 5），出栈序列为（1, 5, 3, 2, 4）是不合法序列。

5.一个数组实现两个栈。

题目不做讲解，仅为代码参考，如有错误欢迎指正！

1.实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O(1)。

template <class T>
class MinStack
{
public:
void Push(const T& x)
{
s1.push(x);
if (s2.empty() || x <= s2.top())
{
s2.push(x);
}
}

void Pop()
{
if (s1.top() == s2.top())
{
s2.pop();
}
s1.pop();
}

T& Min()
{
if (!s2.empty())
{
return s2.top();
}
}

protected:
stack<T> s1;
stack<T> s2;
};

2.使用两个栈实现一个队列。

template <class T>
class Queue
{
public:
void Push(const T& x)
{
if (s2.empty())
{
s1.push(x);
}
else
{
while (!s2.empty())
{
T tmp = s2.top();
s1.push(tmp);
s2.pop();
}
s1.push(x);
}
}

void Pop()
{
if (s2.empty())//将s1的数据全部倒进s2
{
while (!s1.empty())
{
T tmp = s1.top();
s2.push(tmp);
s1.pop();
}
}
T tmp = s2.top();
s2.pop();
}

protected:
stack<T> s1;
stack<T> s2;
};

3.使用两个队列实现一个栈。

template <class T>
class Stack
{
public:
void Push(const T& x)
{
if (q2.empty())
{
q1.push(x);
}
else
{
while (!q2.empty())
{
T tmp = q2.front();
q1.push(tmp);
q2.pop();
}
q1.push(x);
}
}

void Pop()
{
while (q1.size() != 1)
{
T tmp = q1.front();
q2.push(tmp);
q1.pop();
}
q1.pop();
}

protected:
queue<T> q1;
queue<T> q2;
};

4.判断元素出栈、入栈顺序的合法性。如：入栈的序列（1, 2, 3, 4, 5），出栈序列为（4, 5, 3, 2, 1）是合法序列，入栈的序列（1, 2, 3, 4, 5），出栈序列为（1, 5, 3, 2, 4）是不合法序列。

class LegalStack
{
public:
void Push(const T& x)
{
s1.push(x);
}

void Pop()
{
while (!s2.empty())
{
std::cout << s2.top() << " ";
s2.pop();
}
while (!s1.empty())
{
std::cout << s1.top() << " ";
s1.pop();
}
}

void ChangeSort(size_t num = 0)
{
assert(num < s1.size());

while (num--)
{
T tmp = s1.top();
if (!s1.empty())
{
s2.push(tmp);
s1.pop();
}
}
}

protected:
stack<int> s1;
stack<int> s2;
};

5.一个数组实现两个栈。

template <class T>
class DoubleStack
{
public:
DoubleStack()
:_a(NULL)
, _top1(0)
, _top2(0)
, _capacity(0)
{}

void CheckCapacity()
{
if (_a == NULL)
{
_capacity += 3;
_a = new T[_capacity];
_top2 = _capacity - 1;
return;
}
if (_top1 == _top2)
{
size_t capacity = _capacity;
_capacity *= 2;
T* tmp = new T[_capacity];
for (size_t i = 0; i < _top1; i++)//把左边的挪下去
{
tmp[i] = _a[i];
}

for (size_t i = capacity - 1, j = _capacity - 1; i > _top2; i--, j--)//把右边的挪下去
{
tmp[j] = _a[i];
}

delete[] _a;
_a = tmp;
_top2 += _capacity/2;
}
}

void Push1(const T& x)
{
CheckCapacity();
_a[_top1++] = x;
}

void Push2(const T& x)
{
CheckCapacity();
_a[_top2--] = x;
}

void Pop1()
{
_a[_top1--] = T();
}

void Pop2()
{
_a[_top2++] = T();
}

size_t Size1()
{
return _top1;
}

size_t Size2()
{
return _capacity - 1 - _top2;
}

T& Top1()
{
return _a[_top1-1];
}

T& Top2()
{
return _a[_top2 + 1];
}

void Print()
{
cout << "Stack1 is: ";
for (size_t i = 0; i < _top1; i++)
{
cout << _a[i] << " ";
}
cout << endl;

cout << "Stack2 is: ";
for (size_t i = _capacity-1; i > _top2; i--)
{
cout  << _a[i] << " ";
}
cout << endl;
}

protected:
T* _a;
size_t _top1;
size_t _top2;
size_t _capacity;
};