CLRS 10.1栈和队列

10.1-1

10.1-2
第一个栈从 $1$ 到 $n$ 增长，第二个栈从 $n$ 到 $1$ 递减，只有当两个栈指针相邻时再入栈才会溢出 。

10.1-3
图略，在此只给出 Q.head 和 Q.tail。
初始： Q.head = Q.tail = 1；
ENQUEUE(Q,4): Q.head = 1 , Q.tail = 2
ENQUEUE(Q,1): Q.head = 1, Q.tail = 3
ENQUEUE(Q,3): Q.head = 1 , Q.tail = 4
DEQUEUE(Q): Q.head = 2 , Q.tail = 4
ENQUEUE(Q,8): Q.head = 2 , Q.tail = 5
DEQUEUE(Q): Q.head = 3 , Q.tail = 5

10.1-4

ENQUEUE(Q, x)
  if Q.head == (Q.tail + 1) % Q.length
      error "Queue overflow"
  Q[Q.tail] = x
  if Q.tail == Q.length
      Q.tail = 1
  else
      Q.tail = Q.tail + 1

DEQUEUE(Q)
  if Q.head == Q.tail
      error "Queue underflow"
  x = Q[Q.head]
  if Q.head == Q.length
      Q.head = 1
  else
      Q.head = Q.head + 1
  return x

10.1-5
直接上代码

#include <iostream>
using std::cout;
using std::endl;

const int MAX_SIZE = 20;

struct deque_t
{
    int array[MAX_SIZE];
    int head;
    int tail;
};

void init_deque(deque_t *deque)
{
    deque->head = -1;
    deque->tail = 0;
}

bool isEmpty(deque_t *deque)
{
    return deque->head == -1;
}

void push_back(deque_t *deque,int key)
{
    if(deque->head == deque->tail)
    {
        cout << "Deque Overflow" << endl;
        return;
    }
    deque->array[deque->tail] = key;
    if(deque->head == -1)
        deque->head = deque->tail;
    deque->tail = (deque->tail + 1) % MAX_SIZE;
}

int pop_back(deque_t *deque)
{
    if(isEmpty(deque))
    {
        cout << "Deque Underflow" << endl;
        return -1;
    }
    deque->tail = (deque->tail - 1 + MAX_SIZE) % MAX_SIZE;
    if(deque->head == deque->tail)
        deque->head = -1;
    return deque->array[deque->tail];
}

void push_front(deque_t *deque,int key)
{
    if(deque->head == deque->tail)
    {
        cout << "Deque Overflow" << endl;
        return;
    }
    if(deque->head == -1)
        deque->head = deque->tail;
    deque->head = (deque->head - 1 + MAX_SIZE) % MAX_SIZE;
    deque->array[deque->head] = key;
}

int pop_front(deque_t *deque)
{
    if(isEmpty(deque))
    {
        cout << "Deque Underflow" << endl;
        return -1;
    }
    int ret = deque->array[deque->head];
    deque->head = (deque->head + 1) % MAX_SIZE;
    if(deque->head == deque->tail)
        deque->head = -1;
    return ret;
}

void print(deque_t *deque)
{
    if(isEmpty(deque))
        return;
    for(int i = deque->head; i != deque->tail; ++i)
        cout << deque->array[i] << ' ';
}

int main()
{
    deque_t Deque;
    deque_t *deque = &Deque;
    init_deque(deque);
    if(isEmpty(deque))
        cout << "Deque is Empty" << endl;
    push_back(deque,5);
    push_back(deque,2);
    pop_front(deque);
    push_front(deque,9);
    push_back(deque,6);
    pop_front(deque);
    print(deque);
    return 0;
}

10.1-6
设现在有两个栈 $A,B$，入队的时候就将元素 $push$ 到 $B$ 中，出队的时候就从 $A$ 中 $pop$，若 $A$ 空，则将 $B$ 中的元素一个个弹出然后压入到 $A$ 中，然后再弹出。
出队操作是 $O(n)$，入队操作是 $O(1)$。

10.1-7
使用两个队列，将其中一个记做活动队列，每次对栈的压入操作时，都将元素入队到活动队列。每次对栈的弹出操作，把活动队列的元素（除去最后一个元素）入队到非活动队列，然后出队活动队列的元素，同时将活动和非活动队列的标记进行转换。
弹出操作是$O(n)$。