数据结构整理（二） —— 栈和队列

抵制转载并改了作者名的流氓行为，博客地址：http://www.cnblogs.com/wolfred7464/。

书接上文，继续线性表。这次写一下栈和队列的简单实现和部分应用。队列的应用比较简单一些，就像现实中排队一样一样的，就不做过多赘述，主要说一下循环队列的实现，即重用已出队的空间。栈的实现也很简单，这里主要说一下栈的2种常见应用——括号匹配，算数表达式求值。

好了，先说栈吧。栈是一个后进先出的结构，只要保证后进先出，怎么实现都可以，关于代码没太多可说的，下面是一个简单的实现，简单是因为没考虑过多错误处理和动态增长。因为代码量少，所以函数的声明和定义写到一块了：

template <typename T>
class Stack {
private:
    int sp;
    T* _stack;
public:
    Stack(int cap = 1024) {
        sp = 0;
        _stack = new T[cap];
    }
    ~Stack() {
        delete[] _stack;
    }
    void push(const T& x) {
        _stack[sp++] = x;
    }
    void pop() {
        sp--;
    }
    const T& top() {
        return _stack[sp-1];
    }
    void clear() {
        sp = 0;
    }
    inline int size() {
        return sp;
    }
};

利用后进先出的特点，可以利用栈做到函数的递归调用，线程切换等，不过这是操作系统考虑的问题了。这里说一下2个简单的应用。

先说括号匹配，括号匹配就是给出一个字符串，判断字符串中的括号是否是匹配的，例如"sin(a+b)"是匹配的，但是"哈哈:)"就是不匹配的。利用栈，我们把暂时未匹配的前半边括号入栈，当读取到后半边括号且能与栈顶的前半边匹配时，栈顶弹出，完成一个匹配。最好如果栈空，则是匹配的，反之不匹配。代码很简单：

bool brace_match(const char* str) {
    Stack<char> s;
    for(int i = 0; str[i] != ''; i++) {
        if(strchr("()[]{}", str[i]) != NULL) {
            if(str[i] == ')' && s.size() > 0 && s.top() == '(') {
                s.pop();
            } else if(str[i] == ']' && s.size() > 0 && s.top() == '[') {
                s.pop();
            } else if(str[i] == '}' && s.size() > 0 && s.top() == '{') {
                s.pop();
            } else {
                s.push(str[i]);
            }
        }
    }
    return !s.size();
}

void test_brace_match() {
    cout << brace_match("sin(20+10)") << endl;
    cout << brace_match("{[}]") << endl;
}

另一个应用是算数表达式求值，就是给出一个四则运算和小括号组成的算数表达式，按照数学上的优先级计算表达式的结果。就是利用后缀式的做法。我的代码利用2个栈，一个是数字栈，一个是运算符栈，遵循一个简单的规则：

1，数字入数字栈。

2，运算符栈空时，运算符入栈。

3，当前运算符优先级大于栈顶优先级，入栈。

4，左括号"("入栈。

5，读到右括号时，运算符栈依次弹出直到遇到左括号。

6，读取完成后，运算符栈依次全部出栈。

class Evaluation {
private:
    Stack<char> s_op;
    Stack<int> s_num;
    // 比较优先级，判断是否应该入栈
    bool op_cmp(char op_sp, char op_cur);
    // 计算数字栈顶2个数的结果，结果入栈
    void calc(char op);
public:
    int evaluate(const char* str);
};


bool Evaluation::op_cmp(char op_sp, char op_cur) {
    if(op_sp == '(' || op_cur == '(') {
        return true;
    } else if((op_cur == '*' || op_cur == '/') && (op_sp == '+' || op_sp == '-')) {
        return true;
    }
    return false;
}

void Evaluation::calc(char op) {
    int y = s_num.top();
    s_num.pop();
    int x = s_num.top();
    s_num.pop();
    switch(op) {
        case '+':
            x += y; break;
        case '-':
            x -= y; break;
        case '*':
            x *= y; break;
        case '/':
            x /= y; break;
    }
    s_num.push(x);
}

int Evaluation::evaluate(const char* str) {
    s_op.clear();
    s_num.clear();

    int i = 0;
    while(str[i] != '') {
        char c = str[i++];
        if(c >= '0' && c <= '9') {
            int num = c - '0';
            while((c = str[i]) != '') {
                if(c >= '0' && c <= '9') {
                    num = num * 10 + c - '0';
                    i++;
                } else {
                    break;
                }
            }
            s_num.push(num);
        } else if(c == ')') {
            char op = s_op.top();
            s_op.pop();
            while(op != '(') {
                calc(op);
                op = s_op.top();
                s_op.pop();
            }
        } else if(s_op.size() == 0 || op_cmp(s_op.top(), c)) {
            s_op.push(c);
        } else {
            while(s_op.size() > 0 && !op_cmp(s_op.top(), c)) {
                calc(s_op.top());
                s_op.pop();
            }
            s_op.push(c);
        }
    }
    while(s_op.size() > 0) {
        calc(s_op.top());
        s_op.pop();
    }
    return s_num.top();
}

void test_evaluation() {
    Evaluation e;
    cout << e.evaluate("1+2*3") << endl;
    cout << e.evaluate("(1+2)*3") << endl;
    cout << e.evaluate("1+2*3+4+5*2") << endl;
    cout << e.evaluate("1+2*3+(4+5*2)") << endl;
    cout << e.evaluate("1+2*3+((4+5)*2)") << endl;
}

栈的内容先说这些，接下来是队列。由于队列的实现和应用都比较简单，这里只说一下如何实现循环队列，重用已出队的空间，提高效率。循环队列和一般队列一样，只要保证先进先出，并且保证尾结点的后置结点是头结点就可以，用数组，链表，或者其它方式实现都可以，这里我用循环链表演示一下，为了简化编码，数据类型用int，而没有用template：

下面第一个的实现是有问题的。2015.9.25更新新的实现。

class Circularqueue {
private:
    Node* head;
    Node* rear;
    int lenth;
public:
    Circularqueue(int cap = 128);
    ~Circularqueue();
    void enqueue(int data);
    void dequeue();
    int front();
    void clear();
    inline int size();
};

Circularqueue::Circularqueue(int cap) {
    lenth = 0;
    head = new Node();
    rear = head;
    for(int i = 1; i < cap; i++) {
        Node* node = new Node();
        rear->next = node;
        rear = node;
    }
    rear->next = head;
    rear = head;
}

Circularqueue::~Circularqueue() {
    Node* cur = head->next;
    while(cur != nullptr) {
        delete head;
        head = cur;
        cur = cur->next;
    }
    delete head;
}

void Circularqueue::enqueue(int data) {
    rear->data = data;
    rear = rear->next;
    lenth++;
}

void Circularqueue::dequeue() {
    head = head->next;
    lenth--;
}

int Circularqueue::front() {
    return head->data;
}

void Circularqueue::clear() {
    lenth = 0;
    rear = head;
}

int Circularqueue::size() {
    return lenth;
}

#ifndef Circularqueue_hpp
#define Circularqueue_hpp

#include <cassert>

template <typename T>
class Node {
public:
    Node() {
        _next = nullptr;
        _last = nullptr;
    }
    
    inline const T& data() {
        return _data;
    }
    
    inline Node<T>* next() {
        return _next;
    }
    
    inline Node<T>* last() {
        return _last;
    }
    
    inline void set_data(const T& data) {
        _data = data;
    }
    
    void set_next(Node* next) {
        this->_next = next;
        next->_last = this;
    }
    
    void set_last(Node* last) {
        this->_last = last;
        last->_next = this;
    }
    
private:
    T _data;
    
    Node<T>* _next;
    Node<T>* _last;
};


template <typename T>
class Circularqueue {
public:
    Circularqueue() : Circularqueue(128) {
        
    }
    
    Circularqueue(int cap) {
        assert(cap > 1 && "cap must > 1");
        
        _size = 0;
        _cap = cap;
        
        _head = _rear = new Node<T>();
        
        for(int i = 1; i < cap; i++) {
            auto node = new Node<T>();
            _rear->set_next(node);
            _rear = node;
        }
        _rear->set_next(_head);
        _rear = _head;
    }
    
    ~Circularqueue() {
        auto start = _head;
        auto cur = _head->next();
        
        while(cur != start) {
            delete _head;
            
            _head = cur;
            cur = cur->next();
        }
        delete _head;
    }
    
    bool enqueue(const T& data) {
        if(this->full()) {
            return false;
        }
        
        _rear->set_data(data);
        _rear = _rear->next();
        _size++;
        
        return true;
    }
    
    T dequeue() {
        T data = _head->data();
        
        _head = _head->next();
        _size--;
        
        return data;
    }
    
    const T& front() {
        return _head->data();
    }
    
    inline bool empty() {
        return _size <= 0;
    }
    
    inline bool full() {
        return _size >= _cap;
    }
    
    inline int size() {
        return _size;
    }
    
    void clear() {
        _size = 0;
        _rear = _head;
    }
    
private:
    Node<T>* _head;
    Node<T>* _rear;
    
    int _size;
    int _cap;
};

#endif /* CircleQueue_hpp */