判断合法序列

题目描述

假设 I 和 O 分别表示入栈和出栈操作，栈的初态和终态均为空，入栈和出栈的操作序列可表示为仅由 I 和 O 组成的序列，可以操作的序列称为合法序列，否则称为非法序列。编写一个算法，判定所给的序列是否合法。若合法，返回 true，否则返回 false.

解题代码

bool isLegalSequence(const string& sequence) {
    int iCnt = 0;
    for (int i = 0; i < sequence.size(); ++i) {
        if (sequence[i] == 'I') {
            ++iCnt;
        }
        else {
            --iCnt;
        }
        if (iCnt < 0) {
            return false;
        }
    }
    return iCnt == 0;
}

利用栈模拟队列

题目描述

利用两个栈 s1 和 s2 来模拟一个队列，以实现队列的 3 个基本操作，包括入队，出队，判空。

解题代码

template<typename T>
class stackBasedQueue {
private:
    stack<T> s1, s2;
public:
    bool push(const T& t) {
        s1.push(t);
        return true;
    }
    bool pop(T& x) {
        if (!s2.empty()) {
            x = s2.top();
            s2.pop();
            return true;
        }
        else if (!s1.empty()) {
            while (!s1.empty()) {
                int temp = s1.top();
                s1.pop();
                s2.push(temp);
            }
            x = s2.top();
            s2.pop();
            return true;
        }
        else {
            return false;
        }
    }
    bool empty() {
        return s1.empty() && s2.empty();
    }
};

设计队列

题目描述

请设计一个队列，要求满足：（1）初始时队列为空；（2）入队时，允许增加队列占用空间；（3）出队后，出队元素所占用的空间可重复使用，即整个队列所占用的空间只增不减；（4）入队操作和出队操作的时间复杂度始终保持为 O(1).

解题代码

template<typename T>
struct ListNode {
    T val;
    ListNode<T>* next;
    ListNode(T val, ListNode<T>* next) : val(val), next(next) {}
};

template<typename T>
class designedQueue {
private:
    ListNode<T>* front, *rear;
public:
    designedQueue() {
        front = new ListNode<T>(-1, nullptr);
        rear = front;
        rear->next = front;
    }
    bool push(const T& val) {
        if (front == rear->next) {
            rear->next = new ListNode<T>(val, front);
        }
        rear->val = val;
        rear = rear->next;
        return true;
    }
    bool pop(T& x) {
        if (front == rear) {
            return false;
        }
        x = front->val;
        front = front->next;
        return true;
    }
};

递归转非递归

题目描述

利用一个栈实现以下递归函数的非递归运算：

解题代码

int nonRecursive(int n, int x) {
    if (n == 0) return 1;
    else if (n == 1) return 2 * x;
    stack<pair<int, int>> s; // (n, val)
    for (int i = n; i >= 2; --i) {
        s.emplace(i, -1); // 状态压栈
    }
    int v1 = 1, v2 = 2 * n;
    while (!s.empty()) {
        s.top().second = 2 * x * v2 + 2 * (s.top().first - 1) * v1;
        v1 = v2;
        v2 = s.top().second;
        s.pop();
    }
    return v2; // 栈中剩下的唯一值
}