栈的应用 - 符号平衡问题

   在编程语言中，经常需要判断一些符号是否成对出现，比如<>、()、[]、{}，在C++中通常也只有这些对称问题。当然，还有引号的匹配、注释符号的匹配等，在匹配过程中还可能出现转义字符的问题。简便起见，在此只考虑四种括号的匹配问题，并且不考虑转义字符。

   借助于栈，可以很方便的判定一个字符串是否是符号平衡的，具体地，从左至右扫描字符串，如果是左括号，则直接入栈，如果是右括号，则栈顶元素退栈，并且将该元素与当前的右括号进行匹配，如果匹配成功，丢弃这一对括号，继续扫描字符串；如果栈顶元素退栈时栈为空，或者元素不匹配，则说明字符串不是符号平衡的，终止扫描并返回false。当字符串的所有元素扫描完毕时，如果栈为空，则说明字符串是符号平衡的，否则不是符号平衡的。

---

   代码实现

MyStack.h

#ifndef _MYSTACK_H_
#define _MYSTACK_H_

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <iomanip>
using namespace std;

#define INISIZE         2
#define INIINCREMENT    2

#define DYNAMIC

//typedef char elementType;

template <class elementType>
class MyStack {
public:
    int top;
    int size;
    int increment;
    elementType * data;
    MyStack(int size = INISIZE, int increment = INIINCREMENT);
    ~MyStack();
    bool pop(elementType & e);
    bool push(elementType e);
    bool isEmpty();
    bool isFull();
    bool getTopElement(elementType & e);
    void printStack();      //打印栈中所有的元素，主要用于调试
};



template <class elementType> 
MyStack<elementType>::MyStack(int size, int increment)
{
    top = -1;
    this->size = size;
    this->increment = increment;
    data = (elementType *)malloc(sizeof(elementType) * this->size);
}

template <class elementType> 
MyStack<elementType>::~MyStack()
{
    if (data) {
        free(data);
    }
}

template <class elementType> 
bool MyStack<elementType>::pop(elementType & e) 
{
    if (isEmpty()) {
        e = -1;
        return false;
    } else {
        e = data[top];
        top --;
        return true;
    }
}

template <class elementType> 
bool MyStack< elementType>::push(elementType e)
{
    if (isFull()) {
#ifdef DYNAMIC
        size = size + increment;
        data = (elementType *)realloc(data, sizeof(elementType) * this->size);
        if (data == NULL) {
            return false;
        }
        top ++;
        data[top] = e;
        return true;
#else
        return false;
#endif
    } else {
        top ++;
        data[top] = e;
        return true;
    }
}

template <class elementType> 
bool MyStack<elementType>::isEmpty()
{
    return top == -1;
}

template <class elementType> 
bool MyStack<elementType>::isFull()
{
    return top == size - 1;
}

template <class elementType> 
bool MyStack<elementType>::getTopElement(elementType &e)
{
    if (isEmpty()) {
        e = -1;
        return false;
    } else {
        e = data[top];
        return true;
    }
}

template <class elementType> 
void MyStack<elementType>::printStack()
{
    int i;
    cout << "SN\t\telement" << endl; 
    for (i=0;i<=top;i++) {
        cout << i << "\t\t" << data[i] << endl;
    }
    cout << "total elements : " << top+1 << endl;
    cout << "stack size : " << size << endl;
}

#endif

Matches.h

#ifndef _MATCHES_H_
#define _MATCHES_H_

#include "MyStack.h"
#include <string.h>

/*
*  isBalanced : 判断字符串brackets是否是符号平衡的
*/
bool isBalanced(const char * brackets);

#endif

Matches.cpp

#include "Matches.h"

bool match(char src, char dest);

bool isBalanced(const char * brackets)
{
    if (brackets == NULL) {
        return true;
    }
    char e;
    int length = strlen(brackets);
    MyStack<char> stack(length,2);
    const char * pstr = brackets;

    while (*pstr) {
        if ((*pstr=='<') || (*pstr=='{') || (*pstr=='[') || (*pstr=='(')) {
            stack.push(*pstr);
        } else if ((*pstr=='>') || (*pstr=='}') || (*pstr==']') || (*pstr==')')) {
            if (stack.pop(e) == false) {
                return false;
            }
            if (!match(e,*pstr)) {
                return false;
            }
        }
        pstr ++;
    }

    if (stack.isEmpty()) {
        return true;
    } else {
        return false;
    }
}

/*
*  判断src和dest是否是一对匹配的括号
*/
bool match(char src, char dest)
{
    switch(src) {
        case '<':
            if (dest == '>')
                return true;
            else 
                return false;
        case '{':
            if (dest == '}')
                return true;
            else 
                return false;
        case '[':
            if (dest == ']')
                return true;
            else 
                return false;
        case '(':
            if (dest == ')')
                return true;
            else
                return false;
        default:
            return false;
    }
}

test.cpp

#include "Matches.h"

int main()
{
    char str[] = "(){jiels}[{]{}";
    char str2[] = "{([])}jdiewljl";

    if(isBalanced(str)) {
        cout << "str is balanced!" << endl;
    } else {
        cout << "str is not balanced!" << endl;
    }

    if(isBalanced(str2)) {
        cout << "str2 is balanced!" << endl;
    } else {
        cout << "str2 is not balanced!" << endl;
    }

    return 0;
}

   运行结果