栈与队列相关面试题

设计包含min函数的栈

#include <iostream>
#include <vector>
#include <assert.h>
using namespace std;

template <typename T> class CStackWithMin
{
public:
CStackWithMin(void) {}
virtual ~CStackWithMin(void) {}

T& top(void);
const T& top(void) const;

void push(const T& value);
void pop(void);

const T& min(void) const;
private:
vector<T> m_data;
vector<size_t> m_minIndex;
};

template <typename T> T& CStackWithMin<T>::top(void)
{
return m_data.back();
}

template <typename T> const T& CStackWithMin<T>::top(void) const
{
return m_data.back();
}
template <typename T> void CStackWithMin<T>::push(const T& value)
{
m_data.push_back(value);

if(m_minIndex.size() == 0) {
m_minIndex.push_back(0);
} else {
if (value < m_data[m_minIndex.back()]) {
m_minIndex.push_back(m_data.size()-1);
} else {
m_minIndex.push_back(m_minIndex.back());
}
}
}

template <typename T> void CStackWithMin<T>::pop()
{
m_data.pop_back();

m_minIndex.pop_back();
}

template <typename T> const T& CStackWithMin<T>::min() const
{
assert(m_data.size() > 0);
assert(m_minIndex.size() > 0);

return m_data[m_minIndex.back()];
}

堆栈模拟队列

/* START:: code for queue */
typedef struct queue {
stack_t s1[1]; /* for in queue */
stack_t s2[1]; /* for out queue */
} queue_t;

void init_queue(queue_t *q)
{
init_stack(q->s1);
init_stack(q->s2);
}

void in_queue(queue_t *q, int new)
{
push(q->s1, new);
}

int out_queue(queue_t *q)
{
if (!empty(q->s2))
return pop(q->s2);
while (!empty(q->s1)) {
int tmp = pop(q->s1);
push(q->s2, tmp);
}
return pop(q->s2);
}

int q_empty(queue_t *q)
{
return empty(q->s1) && empty(q->s2);
}
/* END:: code for queue */

环形队列

/* START:: code for queue */
#define QUEUE_SIZE 32
int out_queue_err = 0;

typedef struct {
int data[QUEUE_SIZE];
int inpos;
int outpos;
} queue_t;

void init_queue(queue_t *q)
{
memset(q->data, 0, sizeof(int) * QUEUE_SIZE);
q->inpos = q->outpos = 0;
}

int in_queue(queue_t *q, int new)
{
int pos = (q->inpos + 1) % QUEUE_SIZE;
if (pos == q->outpos)
return -1;
q->data[q->inpos] = new;
q->inpos = pos;
return 0;
}

int out_queue(queue_t *q)
{
int ret;

if (q->outpos == q->inpos) {
out_queue_err = -1;
return -1;
}

ret = q->data[q->outpos];
q->outpos = (q->outpos + 1) % QUEUE_SIZE;

return ret;
}

int empty(queue_t *q)
{
return q->inpos == q->outpos;
}
/* END:: code for queue */

队列模拟堆栈

/* START:: code for stack */
typedef struct stack {
queue_t q[2];
int in;
} stack_t;

void init_stack(stack_t *s)
{
init_queue(s->q);
init_queue(s->q + 1);
s->in = 0;
}

int push(stack_t *s, int data)
{
return in_queue(s->q + s->in, data);
}

int pop(stack_t *s)
{
int ret, other;

if (s->in == 0)
other = 1;
else
other = 0;

ret = out_queue(s->q + s->in);
while (!empty(s->q + s->in)) {
in_queue(s->q + other, ret);
ret = out_queue(s->q + s->in);
}
s->in = other;

return ret;
}