C#实现链表zz

链表：链表是用一组任意的存储单元来存储线性表中的数据元素。为此，在存储数据元素时，除了存储数据元 素本身的信息外，还要存储与它相邻的数据元素的存储地址信息。这两部分信息组成该数据元素的存储映像，称为结点(Node)。把存储据元素本身 信息的域叫结点的数据域，把存储与它相邻的数据元素的存储地址信息的域叫结点的引用域。

节点类:

代码

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

namespace  DateStructrues.Lists.Node
{
     ///   <summary>
     ///  节点类。
     ///   </summary>
     ///   <typeparam name="T"></typeparam>
     public   class  DNode < T >
    {
         #region  Fields

         //
         // 数据域
         //
        T _data;

         //
         // 地址域(下一个)
         //
        DNode < T >  _next;

         //
         // 地址域(上一个)
         //
        DNode < T >  _prev;

         #endregion

         #region  Constructor

         ///   <summary>
         ///  构造器
         ///   </summary>
         ///   <param name="value"></param>
         public  DNode(T value)
        {
            _data  =  value;
        }

         ///   <summary>
         ///  构造器
         ///   </summary>
         ///   <param name="value"></param>
         ///   <param name="prev"></param>
         ///   <param name="next"></param>
         public  DNode(T value, DNode < T >  prev, DNode < T >  next)
        {
            _data  =  value;
            _prev  =  prev;
            _next  =  next;
        }

         ///   <summary>
         ///  构造器
         ///   </summary>
         public  DNode() { }

         #endregion

         #region  Properties

         ///   <summary>
         ///  地址域属性（上一个）。
         ///   </summary>
         public  DNode < T >  Prev
        {
             get
            {
                 return  _prev;
            }
             set
            {
                _prev  =  value;
            }
        }

         ///   <summary>
         ///  地址域属性(下一个)。
         ///   </summary>
         public  DNode < T >  Next
        {
             get
            {
                 return  _next;
            }
             set
            {
                _next  =  value;
            }
        }

         ///   <summary>
         ///  数据域属性。
         ///   </summary>
         public  T Data
        {
             get
            {
                 return  _data;
            }
             set
            {
                _data  =  value;
            }
        }

         #endregion
    }
}

链表：

代码

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

namespace  DateStructrues.Lists.Node
{
     ///   <summary>
     ///  链表
     ///   </summary>
     ///   <typeparam name="T"> 数据类型 </typeparam>
     public   class  LinkList < T >  : IList < T >
    {
         #region  Fields

         //
         //  头节点
         //
        Node < T >  head;

         //
         //  尾节点
         //
        Node < T >  rear;

         //
         //  记录节点的个数
         //
         int  count;

         #endregion

         #region  Methods

         ///   <summary>
         ///  通过遍历，求链表的长度。
         ///   </summary>
         ///   <returns> 长度 </returns>
         public   int  GetCount()
        {
             int  count  =   0 ;
            Node < T >  p  =  head;
             while  (p  !=   null )
            {
                count ++ ;
                p  =  p.Next;
            }
             return  count;
        }

         ///   <summary>
         ///  获得节点。
         ///   </summary>
         ///   <param name="index"> 索引 </param>
         ///   <returns> 对应的节点 </returns>
         public  Node < T >  GetNodeByIndex( int  index)
        {
             if  (index  <   0 )
            {
                 return   null ;
            }

            Node < T >  p  =  head;
             int  count  =   0 ;
             while  (p  !=   null )
            {
                 if  (index  ==  count)
                {
                     return  p;
                }
                count ++ ;
                p  =  p.Next;
            }
             return   null ;
        }

         ///   <summary>
         ///  复制
         ///   </summary>
         ///   <returns></returns>
         public  LinkList < T >  Copy()
        {
            LinkList < T >  tmp  =   new  LinkList < T > ();
            tmp.head  =   new  Node < T > (head.Data);
            Node < T >  p1  =  tmp.head;
            Node < T >  p2  =  head.Next;

             while  (p2  !=   null )
            {
                Node < T >  tmpNode  =   new  Node < T > (p2.Data);
                p1.Next  =  tmpNode;

                p1  =  p1.Next;
                p2  =  p2.Next;
            }

             return  tmp;
        }

         ///   <summary>
         ///  倒序
         ///   </summary>
         public   void  Revers()
        {
            Node < T >  p  =  head.Next;
            Node < T >  q  =   new  Node < T > ();
            head.Next  =   null ;
             while  (p  !=   null )
            {
                q  =  p;
                p  =  p.Next;
                q.Next  =  head.Next;
                head.Next  =  q;
            }
        }

         ///   <summary>
         ///  合并
         ///   </summary>
         ///   <param name="Ha"></param>
         ///   <param name="Hb"></param>
         ///   <returns></returns>
         public   static  LinkList < int >  Merge(LinkList < int >  Ha, LinkList < int >  Hb)
        {
            LinkList < int >  Hc  =   new  LinkList < int > ();
            Node < int >  p  =  Ha.head;
            Node < int >  q  =  Hb.head;
            Node < int >  s  =   new  Node < int > ();
            Hc  =  Ha;
            Hc.head  =   null ;
             while  (p  !=   null   &&  q  !=   null )
            {
                 if  (p.Data  <  q.Data)
                {
                    s  =  p;
                    p  =  p.Next;
                }
                 else
                {
                    s  =  q;
                    q  =  q.Next;
                }
                Hc.Add(s.Data);
            }
             if  (p  ==   null )
            {
                p  =  q;
            }
             while  (p  !=   null )
            {
                s  =  p;
                p  =  p.Next;
                Hc.Add(s.Data);
            }
             return  Hc;
        }

         ///   <summary>
         ///  合并,由于同上一个合并方法签名相同,即不能重载
         ///   </summary>
         ///   <param name="Ha"></param>
         ///   <param name="Hb"></param>
         ///   <returns></returns>
         public   static  LinkList < int >  Merge2(LinkList < int >  Ha, LinkList < int >  Hb)
        {
            LinkList < int >  Hc  =   new  LinkList < int > ();
            Node < int >  p  =  Ha.head;
            Node < int >  q  =  Hb.head;
            Node < int >  s  =   new  Node < int > ();
            Hc  =  Ha;
            Hc.head  =   null ;
             // 两个表非空
             while  (p  !=   null   &&  q  !=   null )
            {
                 if  (p.Data  <  q.Data)
                {
                    s  =  p;
                    p  =  p.Next;
                }
                 else
                {
                    s  =  q;
                    q  =  q.Next;
                }
                s.Next  =  Hc.head;
                Hc.head  =  s;
            }
             // 第2个表非空而第1个表为空
             if  (p  ==   null )
            {
                p  =  q;
            }
             // 将两表中的剩余数据元素附加到新表的末尾
             while  (p  !=   null )
            {
                s  =  p;
                p  =  p.Next;
                s.Next  =  Hc.head;
                Hc.head  =  s;
            }
             return  Hc;
        }

         ///   <summary>
         ///  取消
         ///   </summary>
         ///   <param name="Ha"></param>
         ///   <returns></returns>
         public   static  LinkList < int >  Purge(LinkList < int >  Ha)
        {
            LinkList < int >  Hb  =   new  LinkList < int > ();
            Node < int >  p  =  Ha.head;
            Node < int >  q  =   new  Node < int > ();
            Node < int >  s  =   new  Node < int > ();
            s  =  p;
            p  =  p.Next;
            s.Next  =   null ;
            Hb.head  =  s;
             while  (p  !=   null )
            {
                s  =  p;
                p  =  p.Next;
                q  =  Hb.head;
                 while  (q  !=   null   &&  q.Data  !=  s.Data)
                {
                    q  =  q.Next;
                }
                 if  (q  ==   null )
                {
                    s.Next  =  Hb.head;
                    Hb.head  =  s;
                }
            }
             return  Hb;
        }

         #endregion

         #region  Properties

         ///   <summary>
         ///  数组模式，主要用于调试时查看。
         ///   </summary>
         public  T[] ArrayMode
        {
             get
            {
                T[] arr  =   new  T[Count];
                Node < T >  p  =  head;
                 int  count  =   0 ;
                 while  (p  !=   null )
                {
                    arr[count]  =  p.Data;
                    p  =  p.Next;
                    count ++ ;
                }
                 return  arr;
            }
        }

         #endregion

         #region  IList<T> 成员

         ///   <summary>
         ///  求元素所在的索引。
         ///   </summary>
         ///   <param name="item"> 要查找的元素 </param>
         ///   <returns> 所在索引 </returns>
         public   int  IndexOf(T item)
        {
             //  用于遍历链表
            Node < T >  p  =  head;

             //  计数器
             int  count  =   0 ;

             while  (p  !=   null )
            {
                 if  (p.Data.Equals(item))
                {
                     return  count;
                }

                count ++ ;

                 //  移到下一个节点
                p  =  p.Next;
            }
             return   - 1 ;
        }

         ///   <summary>
         ///  插入元素。
         ///   </summary>
         ///   <param name="index"> 索引 </param>
         ///   <param name="item"> 要插入的项 </param>
         public   void  Insert( int  index, T item)
        {
             int  count  =   1 ;
            Node < T >  p  =  head;
            Node < T >  v  =   new  Node < T > (item);
             if  (index  ==   0 )
            {
                 if  (head  ==   null )
                {
                    rear  =  v;
                }

                v.Next  =  head;
                head  =  v;
                 this .count ++ ;
                 return ;
            }

             while  (p  !=   null )
            {
                 if  (count  ==  index)
                {
                     if  (p.Next  ==   null )
                        rear  =  v;
                    v.Next  =  p.Next;
                    p.Next  =  v;

                     this .count ++ ;
                     break ;
                }
                p  =  p.Next;
                count ++ ;
            }
        }

         ///   <summary>
         ///  以索引方式删除元素
         ///   </summary>
         ///   <param name="index"> 索引 </param>
         public   void  RemoveAt( int  index)
        {
             int  count  =   0 ;
             if  (index  ==   0 )
            {
                head  =  head.Next;
                 this .count -- ;
                 return ;
            }
            Node < T >  p  =  head;
            Node < T >  prev  =  head;
             while  (p  !=   null )
            {
                 if  (count  ==  index)
                {
                    prev.Next  =  p.Next;
                     this .count -- ;
                     if  (p.Next  ==   null )
                    {
                        rear  =  prev;
                    }
                     break ;
                }
                prev  =  p;
                p  =  p.Next;
                count ++ ;
            }
        }

         ///   <summary>
         ///  以索引方式访问
         ///   </summary>
         ///   <param name="index"> 索引 </param>
         ///   <returns> 对应的元素 </returns>
         public  T  this [ int  index]
        {
             get
            {
                 try
                {
                    Node < T >  p  =  GetNodeByIndex(index);
                     return  p.Data;
                }
                 catch  (NullReferenceException)
                {
                     throw   new  IndexOutOfRangeException( " 索引超出数组界限。 " );
                }
            }
             set
            {
                 try
                {
                    Node < T >  p  =  GetNodeByIndex(index);
                    p.Data  =  value;
                }
                 catch  (NullReferenceException)
                {
                     throw   new  IndexOutOfRangeException( " 索引超出数组界限。 " );
                }
            }
        }

         #endregion

         #region  ICollection<T> 成员

         ///   <summary>
         ///  向链表末尾，追加元素
         ///   </summary>
         ///   <param name="item"> 要追加的元素 </param>
         public   void  Add(T item)
        {
            Node < T >  p  =   new  Node < T > (item);

             if  (head  ==   null )
            {
                head  =  p;

                 //  将这个节点设为末尾。
                rear  =  p;

                 this .count  =   1 ;
                 return ;
            }

            rear.Next  =  p;
            rear  =  p;

            count ++ ;
        }

         ///   <summary>
         ///  清空
         ///   </summary>
         public   void  Clear()
        {
            head  =   null ;
            rear  =   null ;
        }

         ///   <summary>
         ///  是否包含元素
         ///   </summary>
         ///   <param name="item"> 检查是否包含的元素 </param>
         ///   <returns> 是否存在 </returns>
         public   bool  Contains(T item)
        {
             int  index  =  IndexOf(item);
             return  (index  !=   - 1 );
        }

         ///   <summary>
         ///  将数据拷贝到数组
         ///   </summary>
         ///   <param name="array"> 准备的数组 </param>
         ///   <param name="arrayIndex"> 开始的索引 </param>
         public   void  CopyTo(T[] array,  int  arrayIndex)
        {
            ArrayMode.CopyTo(array, arrayIndex);
        }

         ///   <summary>
         ///  获得此链表的元素个数
         ///   </summary>
         public   int  Count
        {
             get
            {
                 return  GetCount();
            }
        }

         ///   <summary>
         ///  获得是否是只读。
         ///   </summary>
         public   bool  IsReadOnly
        {
             get
            {
                 return   false ;
            }
        }

         ///   <summary>
         ///  删除元素
         ///   </summary>
         ///   <param name="item"> 将要被删除的元素 </param>
         ///   <returns> 是否成功删除 </returns>
         public   bool  Remove(T item)
        {
            Node < T >  prev  =   null ;
            Node < T >  p  =  head;

             while  (p  !=   null )
            {
                 if  (p.Data.Equals(item))
                {
                     if  (prev  !=   null )
                        prev.Next  =  p.Next;
                     else
                        head  =  head.Next;

                     this .count -- ;
                     return   true ;
                }
                prev  =  p;
                p  =  p.Next;

            }
             return   false ;
        }

         #endregion

         #region  IEnumerable<T> 成员

         public  IEnumerator < T >  GetEnumerator()
        {
             throw   new  Exception( " The method or operation is not implemented. " );
        }

         #endregion

         #region  IEnumerable 成员

        IEnumerator IEnumerable.GetEnumerator()
        {
             throw   new  Exception( " The method or operation is not implemented. " );
        }

         #endregion
    }
}