括号匹配算法

///调用方法
///JFrameWork.DataBase.SQL.MatchString sp = new MatchString();
///sp.ParseStr("(1+8*(9-1)+((1-9)+(2*5)))((z)(z)z(55))((666))(59)", "(", ")");
/////////////////实现代码

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;

namespace JFrameWork.DataBase.SQL
{
    /// <summary>
    /// 匹配对的结构存储体
    /// </summary>
    struct MS
    {
        public int left;
        public int right;
        public MS(int left, int right)
        {
            this.left = left;
            this.right = right;
        }

        public MS(MS ms)
        {
            this.left = ms.left;
            this.right = ms.right;
        }
    }

    public class MatchString
    {
        /// <summary>
        /// 左值队列
        /// </summary>
        List<int> llist = new List<int>();
        /// <summary>
        /// 右值队列
        /// </summary>
        List<int> rlist = new List<int>();
        /// <summary>
        /// 左右值混合队列
        /// </summary>
        List<int> alllist = new List<int>();
        /// <summary>
        /// 匹配对存储队列
        /// </summary>
        List<MS> matchmap = new List<MS>();

        public void ParseStr(string str, string lvalue, string rvalue)
        {
            System.Console.WriteLine("str : {0}", "01234567890123456789012345678901234567890123456789");
            System.Console.WriteLine("str : {0}", str);
            GetIndex(str, lvalue, rvalue);
            SetAllList();
            GetNearMatch();
            GetRootMatch();
            DisplayMatchMap();
        }

        /// <summary>
        /// 得到串的左值以及右值队列序号分别存放在llist以及rlist中
        /// </summary>
        /// <param name="str"></param>
        /// <param name="lvalue"></param>
        /// <param name="rvalue"></param>
        void GetIndex(string str, string lvalue, string rvalue)
        {
            int lstartIndex = 0;
            int rstartIndex = 0;
            bool lb = true;
            bool rb = true;
            while (lb || rb)
            {
                if (lb)
                {
                    lstartIndex = str.IndexOf(lvalue, lstartIndex);
                    if (lstartIndex >= 0)
                    {
                        llist.Add(lstartIndex);
                        System.Console.WriteLine("LValue Index: {0}", lstartIndex);
                        lstartIndex++;
                    }
                    else
                    {
                        lb = false;
                    }
                }
                if (rb)
                {
                    rstartIndex = str.IndexOf(rvalue, rstartIndex);
                    if (rstartIndex >= 0)
                    {
                        rlist.Add(rstartIndex);
                        System.Console.WriteLine("RValue Index: {0}", rstartIndex);
                        rstartIndex++;
                    }
                    else
                    {
                        rb = false;
                    }
                }
            }

        }

        /// <summary>
        /// 设置llist以及rlist中所有的索引序号内容导入到ALLList，并按序号进行排序
        /// </summary>
        void SetAllList()
        {
            for (int i = 0; i < llist.Count; i++)
            {
                alllist.Add(llist[i]);
            }
            for (int i = 0; i < rlist.Count; i++)
            {
                alllist.Add(rlist[i]);
            }
            alllist.Sort();
        }

        /// <summary>
        /// 将alllist中找到最相近的匹配对到matchmap中存储
        /// </summary>
        void GetNearMatch()
        {
            Stack<int> stack = new Stack<int>();
            for (int i = 0; i < alllist.Count; i++)
            {
                if (llist.Contains(alllist[i]))
                {
                    stack.Push(alllist[i]);
                }
                else if (rlist.Contains(alllist[i]))
                {
                    if (stack.Peek() < alllist[i])
                    {
                        int tmp = stack.Pop();
                        matchmap.Add(new MS(tmp, alllist[i]));
                        System.Console.WriteLine("NeerMatch : {0}\t{1}", tmp, alllist[i]);
                    }
                }
            }
        }

 

//本处最终结果尽管是对的 但是我认为这只是一个碰巧得到了正确的结果,而且算法好像也有些问题
//希望有人能解决得到更好的算法
        /// <summary>
        /// 对matchmap对进行搜索过滤，得到最终的根级匹配对，并返回
        /// </summary>
        /// <returns></returns>
        List<MS> GetRootMatch()
        {
            List<MS> tmp = new List<MS>();

            for (int i = 0; i < matchmap.Count; i++)
            {
                MS ms = new MS(matchmap[i]);
                for (int j = i + 1; j < matchmap.Count; j++)
                {
                    if (matchmap[j].left < matchmap[i].left && matchmap[j].right > matchmap[i].right)
                    {
                        ms = new MS(matchmap[j]);
                        if (!tmp.Contains(ms))
                        {
                            tmp.Add(ms);
                            //System.Console.WriteLine("RootMatch : {0}\t{1}", ms.left, ms.right);
                        }

                    xxx:
                        for (int k = 0; k < matchmap.Count; k++)
                        {
                            for (int l = 0; l < tmp.Count; l++)
                            {
                                if (matchmap[k].left > tmp[l].left && matchmap[k].right < tmp[l].right)
                                {
                                    matchmap.RemoveAt(k);
                                    goto xxx;
                                }
                            }
                        }
                    }

                }

            }
            return matchmap;
        }

        void DisplayMatchMap()
        {
            foreach (MS ms in matchmap)
            {
                System.Console.WriteLine("MatchMap: [L] {0}\t [R] {1}",ms.left, ms.right);
            }
        }

    }
}