栈和队列

stack

#include "vector.hpp"

template <typename T>
class Stack : public Vector<T>
{
public:
    void push(T const &e) { insert(size(), e); }
    T pop() { return remove(size() - 1); }
    T &top() { return (*this)[size() - 1]; }
};
void convert(Stack<char> &S, _int64 n, int base)
{
    static char digit[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
    while (n > 0)
    {
        int remainder = (int)(n % base);
        S.push(digit[remainder]);
        n /= base;
    }
}
bool paren(const char exp[], int lo, int hi)
{
    Stack<char> S;
    for (int i = lo; i <= hi; i++)
        switch (exp[i])
        {
        case '(':
        case '[':
        case '{':
            S.push(exp[i]);
            break;
        case ')':
            if (S.empty() || '(' != S.pop())
                return false;
            break;
        case ']':
            if (S.empty() || ']' != S.pop())
                return false;
            break;
        case '}':
            if (S.empty() || '}' != S.pop())
                return false;
            break;
        default:
            break;
        }
    return S.empty();
}
#define N_OPTR 9 // 运算符总数
typedef enum
{
    ADD,
    SUB,
    MUL,
    DIV,
    POW,
    FAC,
    L_P,
    R_P,
    EOE
} Operator; // 运算符集合
// 加、减、乘、除、乘方、阶乘、左括号、右括号、起始符与终止符
const char pri[N_OPTR][N_OPTR] = { // 运算符优先等级 [栈顶] [当前]
    /* |-------------------- 当 前 运 算 符 --------------------| */
    /*           +    -    *    /    ^    !    (    )   \0   */
    /* -- + */ '>', '>', '<', '<', '<', '<', '<', '>', '>',
    /* | - */ '>', '>', '<', '<', '<', '<', '<', '>', '>',
    /* 栈 * */ '>', '>', '>', '>', '<', '<', '<', '>', '>',
    /* 顶 / */ '>', '>', '>', '>', '<', '<', '<', '>', '>',
    /* 运 ^ */ '>', '>', '>', '>', '>', '<', '<', '>', '>',
    /* 算 ! */ '>', '>', '>', '>', '>', '>', ' ', '>', '>',
    /* 符 ( */ '<', '<', '<', '<', '<', '<', '<', '=', ' ',
    /* | ) */ ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
    /* -- \0 */ '<', '<', '<', '<', '<', '<', '<', ' ', '='};
float evaluate(char *S, char *&RPN)
{
    Stack<float> opnd;
    Stack<char> optr;
    optr.push('\0');
    while (!optr.empty())
    {
        if (isdigit(*S))
        {
            readNumber(S, opnd);
            append(RPN, opnd.top());
        }
        else
            switch (orderBetween(optr.top(), *S))
            {
            case '<':
                optr.push(*S);
                S++;
                break;
            case '=':
                optr.pop();
                S++;
                break;
            case '>':
            {
                char op = optr.pop();
                append(RPN, op);
                if ('!' == op)
                {
                    float p0pnd = opnd.pop();
                    opnd.push(calcu(op, p0pnd));
                }
                else
                {
                    float p0pnd2 = opnd.pop(), p0pnd1 = opnd.pop;
                    opnd.push(calcu(p0pnd1, op, p0pnd2));
                }
                break;
            }
            default:
                exit(-1);
            }
    }
    return opnd.pop();
}
void readNumber(char *&p, Stack<float> &stk)
{
    stk.push((float)(*p - '0'));
    while (isdigit(*(++p)))
        stk.push(stk.pop() * 10 + (*p - '0'));
    if ('.' != *p)
        return;
    float fraction = 1;
    while (isdigit(*(++p)))
        stk.push(stk.pop() + (*p - '0') * (fraction /= 10));
}
Operator optr2rank(char op)
{ // 由运算符转译出编号
    switch (op)
    {
    case '+':
        return ADD; // 加
    case '-':
        return SUB; // 减
    case '*':
        return MUL; // 乘
    case '/':
        return DIV; // 除
    case '^':
        return POW; // 乘方
    case '!':
        return FAC; // 阶乘
    case '(':
        return L_P; // 左括号
    case ')':
        return R_P; // 右括号
    case '\0':
        return EOE; // 起始符不终止符
    default:
        exit(-1); // 未知运算符
    }
}
char orderBetween(char op1, char op2)
{
    return pri[optr2rank(op1)][optr2rank(op2)];
}
void append(char *&rpn, float opnd)
{
    int n = strlen(rpn);
    char buf[64];
    if (opnd != (float)(int)opnd)
        sprintf(buf, "%.2f\0", opnd);
    else
        sprintf(buf, "%d \0", (int)opnd);
    rpn = (char *)realloc(rpn, sizeof(char) * (n + strlen(buf) + 1));
    strcat(rpn, buf);
}
void append(char *&rpn, char optr)
{
    int n = strlen(rpn);
    rpn = (char *)realloc(rpn, sizeof(char) * (n + 3));
    sprintf(rpn + n, "%c", optr);
    rpn[n + 2] = '\0';
}

queue

#include "list.hpp"
template <typename T>
class Queue : public : List<T>
{
public:
    void qnqueue(T const &e) { insertAsLast(e); }
    T dequeue() { return remove(first()); }
    T &front() { return first()->data; }
};