C++数据结构第35课、栈的概念及实现（下）

1、StaticStack 的缺陷

模板类型为类类型时，StaticStack 的对象在创建时，会多次调用元素类型的构造函数，便会极大的影响效率。

main.cpp

#include <iostream>
#include "StaticStack.h"
using namespace std;
using namespace XiebsLib;

class Test
{
public:
    Test()
    {
        cout << "Test" << endl;
    }
    ~Test()
    {
        cout << "~Test" << endl;
    }
};

int main()
{
    StaticStack<Test, 5> stack;
    cout << stack.size() << endl;
    return 0;
}

为什么会这样输出这样的结果？

我们创建了 stack 对象，调用了 StaticStack<Test, 5> 的构造函数，并且成员变量是这样的写的：

protected:
    T m_space[N];
    int m_top;
    int m_size;

T 为 Test，于是会调用Test 类的构造函数，有5个元素，调用5次。这极大的影响了效率。那么我们此时是不是需要一种新的栈的存储方式呢？

我们可以开发出一种新的链式栈，它的实现方式如下图所示

• 链式栈的设计要点
  1、类模板，抽象父类 Stack 的直接子类
  2、在内部组合使用 LinkList 类，实现栈的链式存储
  3、只在单链表成员对象的头部进行操作

LinkStack.h

#ifndef LINKSTACK_H
#define LINKSTACK_H

#include "Stack.h"
#include "LinkList.h"
#include "Exception.h"

namespace XiebsLib
{

template <typename T>
class LinkStack : public Stack<T>
{
protected:
    LinkList<T> m_list;
public:
    void push(const T& e)
    {
        m_list.insert(0, e);
    }

    void pop()
    {
        if(m_list.length() > 0)
        {
            m_list.remove(0);
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No element in current Stack");
        }
    }

    T top()const
    {
        if(m_list.length() > 0)
        {
            return m_list.get(0);
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No element in current Stack");
        }
    }

    void clear()
    {
        m_list.clear();
    }

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

};
}
#endif // LINKSTACK_H

main.cpp

#include <iostream>
#include "LinkStack.h"
using namespace std;
using namespace XiebsLib;

class Test: public Object
{
public:
    Test()
    {
        cout << "Test" << endl;
    }
    ~Test()
    {
        cout << "~Test" << endl;
    }
};

int main()
{
    LinkStack<Test> stack;
    cout << stack.size() << endl;
    return 0;
}

我们看到此时显然已经不再调用 Test 类的构造函数了。

2、符号匹配问题

在 C 语言中有一些成对出现的符号，如括号：()， []， {}， <>，再如引号：’ '， " "。该如何实现编译器中的符号成对检测呢？

算法思路：

1、从第一个字符开始扫描：当遇见普通字符时忽略；当遇见左符号时压入栈中；当遇见右符号时弹出栈顶符号，并进行匹配。
2、结束：成功时，所有字符扫描完毕，且栈为空；失败时，匹配失败或所有字符扫描完毕但栈非空。

main.cpp

#include <iostream>
#include "LinkStack.h"
using namespace std;
using namespace XiebsLib;

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)
{
    bool ret = true;
    LinkStack<char> stack;
    code = ((code == nullptr) ? "" : code);
    int i = 0;

    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()
{
    cout << scan("\"<a{b(\'e\')c}d>\" ") << endl;
    return 0;
}

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