栈与队列相关面试题

设计包含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;
}