链式栈LinkStack的实现

上一篇是讲解StaticStack的实现，但是有一个的问题：

由于顺序栈内部实现是采用原生数组来实现的，当存储的元素为类类型时，StaticStack 的对象在创建时，会多次调用元素类型的构造函数，这样就会影响效率。这时候就需要设计链式栈。

链式栈的设计

（1）类模板， 抽象父类 Stack 的直接子类；
（2）在内部组合使用 Linklist 类 ，实现栈的链式存储；
（3）只在单链表成员对象的头部进行操作
其实只在链表尾部操作也是可以的，但是只是在头部进行操作的时候效率更高，不需要太多的移动次数。
代码：

#ifndef _LINKSTACK_H_
#define _LINKSTACK_H_

/*
    链式栈
*/
#include "Stack.h"
#include "LinkList.h"

namespace DTLib
{
    template < typename T >

    class LinkStack : public Stack<T>
    {
    protected:
        LinkList<T> m_list; // 组合使用单链表类
    public:
        // 构造函数都不需要
        // 只在头部操作
        void push(const T& e) // O(1)
        {
            m_list.insert(0, e); // 头插
        }
        void pop() // O(1)
        {
            if (m_list.length() > 0)
            {
                m_list.remove(0); // 头取
            }
            else
            {
                THROW_EXCEPTION(InvalidOperationException, "No element in current stack ...");
            }
        }

        T top() const // O(1)
        {
            if (m_list.length() > 0)
            {
                return m_list.get(0);
            }
            else
            {
                THROW_EXCEPTION(InvalidOperationException, "No element in current stack ...");
            }
        }
        void clear()  // O(n)
        {
            m_list.clear();
        }

        int size() const // O(1)
        {
            return m_list.length();
        }

    };
}

#endif

栈的应用——符号匹配问题

#include <iostream>
#include "LinkStack.h"

using namespace std;
using namespace DTLib;


bool is_left(char c)
{
    return (c == '(') || (c == '{') || (c == '[') || (c == '<');
}

bool is_right(char c)
{
    return (c == ')') || (c == '}') || (c == ']') || (c == '>');
}

bool is_quot(char c)
{
    return (c == '\'') || (c == '\"');
}

bool is_match(char l, char r)
{
    return ((l == '(') && (r == ')')) ||
        ((l == '{') && (r == '}')) ||
        ((l == '[') && (r == ']')) ||
        ((l == '<') && (r == '>')) ||
        ((l == '\'') && (r == '\'')) ||
        ((l == '\"') && (r == '\"'));
}

bool scan(const char* code)
{
    LinkStack<char> stack;
    int i = 0;
    bool ret = true;

    code = (code == NULL) ? "" : code;

    while (ret && (code[i] != '\0'))
    {
        if (is_left(code[i]))
        {
            stack.push(code[i]);
        }
        else if (is_right(code[i]))
        {
            // 进行匹配，能匹配的时候栈肯定不是空的
            if ((stack.size() > 0) && is_match(stack.top(), code[i]))
            {
                stack.pop();
            }
            else
            {
                ret = false;
            }
        }
        else if (is_quot(code[i])) // 是引号进行单独处理
        {
            if ((stack.size() == 0) || !is_match(stack.top(), code[i])) // 认为是左
            {
                stack.push(code[i]);
            }
            else if (is_match(stack.top(), code[i]))
            {
                stack.pop();
            }
        }

        i++;
    }


    return ret && (stack.size() == 0);
}

int main(void)
{

    cout << scan("<a{b(\'x\')c}d>") << endl;

    cout << scan("\"<a{b(\'x\')c}d>\"") << endl;

    cout << scan("}") << endl;

    cout << scan("if ((stack.size() == 0) || !is_match(stack.top(), code[i])){stack.push(code[i]);}else if (is_match(stack.top(), code[i])){stack.pop();}") << endl;


    return 0;
}

小结：
（1）链式栈的实现组合使用了单链表对象；
（2）在单链表的头部进行操作能够实现高效的入栈和出栈操作；
（3）栈的“后进先出”的特性适用于检测成对出现的符号；
（4）栈非常适合于需要“就近匹配”的场合。