数据结构实验 第四单元 串操作

namespace 串和数组
{
    //顺序串
    internal class SeqString
    {
        ValueType[] data;
        int maxLen,len;
        public SeqString()
        {
            len=0;
            maxLen = 0;
            data = new ValueType[0];
        }
        public SeqString(int maxLen)
        {
            Create(maxLen);
        }
        public SeqString(int maxLen, string str)
        {
            Create(maxLen);
            foreach (var ele in str)
            {
                data[len++] = ele;
            }
        }



        /// <summary>
        /// 建立新串
        /// </summary>
        /// <param name="maxLen"></param>
        public void Create(int maxLen)
        {
            len=0;
            this.maxLen = maxLen;
            data = new ValueType[maxLen];
        }

        /// <summary>
        /// 判断是否为空串
        /// </summary>
        /// <returns></returns>
        public Boolean Empty()
        {
            return len == 0;
        }

        public int Length { get { return len; } }

        /// <summary>
        /// 获取制定下标的元素
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public ValueType Get(int index)
        {
            if (index >= 0 && index < len)
            {
                return data[index];
            }
            else
            {
                throw new IndexOutOfRangeException();
            }
        }

        /// <summary>
        /// 修改指定下标的值
        /// </summary>
        /// <param name="index"></param>
        /// <param name="obj"></param>
        public void Set(int index, ValueType vt)
        {
            if (index >= 0 && index < len)
            {
                data[index] = vt;
            }
            else
            {
                throw new IndexOutOfRangeException();
            }
        }

        public ValueType this[int index]
        {
            get {
                return Get(index);
            }
            set {
                Set(index, value);
            }

        }

        /// <summary>
        /// 将该串复制到另外一个串
        /// </summary>
        /// <param name="ss"></param>
        public void CopyTo(SeqString ss)
        {
            ss.Create(maxLen);
            for (int i = 0; i < len; i++)
            {
                //值类型直接赋值即可
                ss[i] = data[i];
            }

        }

        /// <summary>
        /// 比较串。如果本串大于ss，则返回值大于0；等于则等于0；小于则小于0。
        /// </summary>
        /// <param name="ss"></param>
        /// <returns></returns>
        public int Compare(SeqString ss)
        {
            for (int i = 0; i < len && i < ss.len; i++)
            {
                if (data[i] != ss[i])
                {
                    return (int)(data[i])-(int)(ss[i]);
                }
            }
            return len - ss.len;
        }

        /// <summary>
        /// 将串连接到本串尾部
        /// </summary>
        /// <param name="ss"></param>
        public Boolean Join(SeqString ss)
        {
            if (len + ss.len > maxLen)
            {
                return false;
            }
            for (int i = 0; i < ss.len; i++)
            {
                data[len++] = ss[i];
            }
            
            return true;
        }

        /// <summary>
        /// 在本串的制定位置中插入一个串
        /// </summary>
        /// <param name="ss"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        public Boolean Insert(SeqString ss,int index)
        {
            if (len + ss.len > maxLen)
            {
                return false;
            }
            
            for (int i = len - 1; i >= index; i--)
            {
                data[i + ss.len] = data[i];
            }

            for (int i = 0; i < ss.len; i++)
            {
                data[index + i] = ss[i];
            }
            len += ss.len;
            return true;
        }

        /// <summary>
        /// 删除制定位置的串元素
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public Boolean Remove(int index,int count=1)
        {
            if (index + count >= len || count<0)
            {
                return false;
            }

            for (int i = index; i < len - count; i++)
            {
                data[i] = data[i + count];
            }
            len -= count;
            return true;
        }
       
        public override string ToString()
        {
            System.Text.StringBuilder sb = new StringBuilder(maxLen);
            for (int i = 0; i < len; i++)
            {
                sb.Append(data[i]);
            }
            return sb.ToString();
        }
        /// <summary>
        /// 查找子串
        /// </summary>
        /// <param name="ss"></param>
        /// <returns></returns>
        public int Find(SeqString ss)
        {
            //模式匹配，Sunday算法。
            Boolean ok = false;
            int matched=0,start=0;
            if(ss.len>Length)
            {
                return -1;
            }
            int i;
            for (i = 0; i < Length; i++)
            {
                if (matched<ss.len && data[i].Equals(ss.Get(matched)))
                {
                    if(ok==false)
                    {
                        //记录 开始匹配 的位置
                        start=i;
                    }
                    ok = true;
                    matched++;
                }
                else
                {

                    if (matched == ss.len)
                    {
                        //已完成匹配
                        return i - matched;
                    }
                    else
                    { 
                        //未完成匹配
                        if (start + ss.Length < len)
                        {
                            i = start + ss.Length;
                            start = i;
                            Boolean hasSim = false;
                            int j;
                            for (j = 0; j < ss.len; j++)
                            {
                                if (ss.Get(j).Equals(data[i]))
                                {
                                    hasSim = true;
                                    break;
                                }
                            }
                            if (hasSim)
                            {
                                //在模式串中存在下一个字符
                                //将 子串中的这个字符 与 主串中的 字符 对齐
                                i = i - j;
                                start = i;
                                i--;
                                //抵消for循环的i++。
                            }
                        }
                        else
                        {
                            return -1;
                        }
                        matched = 0;
                        ok = false;
                    }
                }
            }
            if (matched == ss.len)
            {
                //已完成匹配
                return i - matched;
            }
            return -1;
        }

        /// <summary>
        /// 截取字符串
        /// </summary>
        /// <returns></returns>
        public SeqString Substring(int startIndex,int count)
        {
            System.Text.StringBuilder sb = new StringBuilder(256);
            
            for (int i = startIndex; i < len && i - startIndex < count; i++)
            {
                sb.Append(data[i].ToString());
            }

            return new SeqString(sb.Length, sb.ToString());
        
        }
       
    }
}

转载于:https://www.cnblogs.com/tinyjian/p/6550705.html