加班后，余兴未了，写了个链表，呵呵放出来充实下blog先

 /**//// <summary>
    /// 结点
    /// </summary>
    /// <typeparam name="T">泛型对象</typeparam>
    internal class LNode<T>
    ...{
        /**//// <summary>
        /// 构造函数
        /// </summary>
        public LNode()
        ...{
        }

        /**//// <summary>
        /// 构造函数 设置泛型值
        /// </summary>
        /// <param name="NodeValue">结点</param>
        public LNode(T NodeValue)
        ...{
            _Data = NodeValue;
        }

        private T _Data=default (T) ;
        /**//// <summary>
        /// 值
        /// </summary>
        public T Data
        ...{
            get ...{ return _Data; }
            set ...{ _Data = value; }
        }

        private LNode<T> _Next=null ;
        /**//// <summary>
        /// 下一个节点
        /// </summary>
        public LNode<T> Next
        ...{
            get ...{ return _Next; }
            set ...{ _Next = value; }
        }

    }

 

上面是结点

下面是表定义

 

 /**//// <summary>
    /// 单链表
    /// </summary>
    public class LinkList<T>
    ...{
        /**//// <summary>
        /// 构造函数
        /// </summary>
        public LinkList()
        ...{
            //表头等于表尾
            _EndNode = _HeadNode;
        }

        /**//// <summary>
        /// 索引
        /// </summary>
        /// <param name="index">索引ID</param>
        /// <returns>结点值</returns>
        public T this[int index]
        ...{
            get
            ...{
                return GetData(index);
            }
            set
            ...{
                Modify(index, value);
            }
        }

        private int _Length = 0;
        /**//// <summary>
        /// 单链表长度
        /// </summary>
        public int Length
        ...{
            get ...{ return _Length; }
        }


        private LNode<T> _HeadNode=new LNode<T> ();     //头结点
        private LNode<T> _EndNode = new LNode<T>();      //尾结点

        /**//// <summary>
        /// 寻找结点
        /// </summary>
        /// <param name="index">索引ID</param>
        /// <returns>结点</returns>
        /// <exception cref="System.IndexOutOfRangeException">索引号超出单链表长度</exception>
        private LNode<T> Find(int index)
        ...{
            if (index >= _Length) throw new IndexOutOfRangeException("索引号超出单链表长度");
            LNode<T> FindNode=new LNode<T> ();
            FindNode = _HeadNode.Next;
            for (int iCount = 0; iCount < index; iCount++)
            ...{
                FindNode = FindNode.Next;
            }
            return FindNode;
        }

        /**//// <summary>
        /// 得到结点值
        /// </summary>
        /// <param name="index">索引ID</param>
        /// <returns>结点值</returns>
        public T GetData(int index)
        ...{
            //索引不合法
            if (index < 0 || index >= _Length) return default(T);
            //返回找到的值
            return Find(index).Data;
        }

        /**//// <summary>
        /// 表尾添加结点
        /// </summary>
        /// <param name="NodeValue">结点值</param>
        public void Append(T NodeValue)
        ...{
            LNode<T> NewNode = new LNode<T>(NodeValue);
            _EndNode.Next = NewNode;
            _EndNode = NewNode;
            if(_Length==0) _HeadNode .Next =NewNode ;
            ++_Length;
        }

        /**//// <summary>
        /// 插入表头
        /// </summary>
        /// <param name="NodeValue">结点值</param>
        public void InsertFirst(T NodeValue)
        ...{
            LNode<T> ListNode = new LNode<T>(NodeValue);
            ListNode.Next = _HeadNode.Next;
            _HeadNode.Next = ListNode;
            //如果为空表 尾结点设置
            if (_Length == 0) _EndNode = ListNode;
            ++_Length;
        }

        /**//// <summary>
        /// 插入结点 索引之前
        /// </summary>
        /// <param name="index">索引ID</param>
        /// <param name="NodeValue">结点值</param>
        /// <returns>true表示插入成功，false表示插入失败</returns>
        public bool InsertBefore(int index, T NodeValue)
        ...{
             //如果小于长度 返回假
            if (index < 0 || index >= _Length) return false;
            //如果为头结点
            if (index == 0)
            ...{
                LNode<T> InsertNode = new LNode<T>(NodeValue);
                InsertNode.Next = _HeadNode.Next;
                _HeadNode.Next = InsertNode;
                ++_Length;
                return true;
            }
            //如果为中间结点
            LNode<T> FindNode = Find(index - 1);
            LNode<T> InsNode=new LNode<T> (NodeValue );
            InsNode.Next = FindNode.Next;
            FindNode.Next = InsNode;
            ++_Length;
            return true;
        }

        /**//// <summary>
        /// 插入结点 索引之后
        /// </summary>
        /// <param name="index">索引ID</param>
        /// <param name="NodeValue">结点值</param>
        /// <returns>true表示插入成功，false表示插入失败</returns>
        public bool InsertAfter(int index, T NodeValue)
        ...{
            //如果小于长度 返回假
            if (index < 0 || index >= _Length) return false;
            //如果为尾结点
            if (index == _Length-1)
            ...{
                Append(NodeValue);
                return true;
            }
           
            //如果为中间结点
            LNode<T> FindNode = Find(index);
            LNode<T> InsertNode = new LNode<T>(NodeValue);
            InsertNode.Next = FindNode.Next;
            FindNode.Next = InsertNode;
            ++_Length;
            return true;
        }

        /**//// <summary>
        /// 修改结点值
        /// </summary>
        /// <param name="index">索引ID</param>
        /// <param name="NodeValue">结点值</param>
        /// <returns>true表示修改成功，false表示修改失败</returns>
        public bool Modify(int index, T NodeValue)
        ...{
            //索引不合法
            if (index < 0 || index >= _Length) return false;
            //如果为尾结点
            if (index == _Length - 1)
            ...{
                _EndNode.Data = NodeValue;
                return true;
            }
            //如果为中间结点
             Find(index).Data =NodeValue ;
             return true;
        }

        /**//// <summary>
        /// 删除结点值
        /// </summary>
        /// <param name="index">索引ID</param>
        /// <returns>删除的结点值</returns>
        public T Delete(int index)
        ...{
            //索引不合法
            if (index < 0 || index >= _Length) return default(T);
            //如果为头结点
            if (index == 0)
            ...{
                LNode<T> DelNode = _HeadNode.Next;
                _HeadNode.Next = DelNode.Next;
                --_Length;
                return DelNode.Data;
            }

            LNode<T> FindNode = Find(index - 1);
            LNode<T> DelNode2 = FindNode.Next;
            FindNode.Next = DelNode2.Next;             //也可以是FindNode.Next = FindNode.Next.Next
            --_Length;
            return DelNode2.Data;
        }

       
       
    }

 

慢慢把他完善

用microsoft自带的类分词 10w 2秒，自己的大概要8秒左右，所以决定优化自己的基础类。一步一步来，慢慢优化

总有一天超越他。虽然已经解决10w分词1秒搞定，不过学无止境，所以day day study,day day up