KMP算法 字符串匹配

按照上文的思路，自己写了一个KMP算法来实现字符串匹配，可以判断短字符串是否匹配长字符串以及第一次匹配成功时长字符串的初始位置。

class KMPClass
    {
        string longString;

        bool IsMatch;

        int matchPlace;//匹配数组在长数组中第一个字符的位置

        public string LongString
        {
            get
            {
                return longString;
            }
            set
            {
                longString = value;
            }
        }

        string shortString;

        public string ShortString
        {
            get { return shortString; }
            set { shortString = value; }
        }

        int[] next;

        public KMPClass()
        {
            next = new int[300];

        }

        public void GetNext()
        {
            int len = 0;
            while (len <= shortString.Length)
            {
                int maxLen = 0;
                for (int i = 1; i <= len / 2; i++)
                {
                    bool flag = true;
                    for (int j = 0; j < i; j++)
                    {
                        if (shortString[j] != shortString[len - i + j])
                        {
                            flag = false;
                            break;
                        }
                    }
                    if (flag == true)
                    {
                        maxLen = i;
                    }

                }
                next[len] = maxLen;

                len++;
            }


        }

        public void IsMatchOrNot()
        {
            if (longString=="")
            {
                IsMatch = false;
                return;
            }
            GetNext();
            int shortPosition=0; 
            
            int longPosition=0;
            
            int shortLen = shortString.Length;
            
            int longLen = longString.Length;

            while (true)
            {
                if (shortPosition==shortLen)
                {
                    IsMatch = true;

                    matchPlace = longPosition - shortLen ;

                    return;
                }
                if (longPosition==longLen)
                {
                    IsMatch = false;
                    return;
                }
                if (shortString[shortPosition]==longString[longPosition])
                {
                    shortPosition++;
                    longPosition++;
                }
                else
                {
                    shortPosition=next[shortPosition+1];
                    longPosition = longPosition +shortPosition+1- next[shortPosition + 1];
                }
            }

        }
        


    }