C#数据结构－线性表

理论基础：  

   线性表是最简单、最基本、最常用的数据结构。线性表是线性结构的抽象(Abstract)，线性结构的特点是结构中的数据元素之间存在一对一的线性关系。这种一对一的关系指的是数据元素之间的位置关系，即：

    （1）除第一个位置的数据元素外，其它数据元素位置的前面都只有一个数据元素；

    （2）除最后一个位置的数据元素外，其它数据元素位置的后面都只有一个元素。

      也就是说，数据元素是一个接一个的排列。因此，可以把线性表想象为一种数据元素序列的数据结构。

     线性表(List)是由n(n≥0)个相同类型的数据元素构成的有限序列.

     注意：“有限”，指的是线性表中的数据元素的个数是有限的，线性表中的每一个数据元素都有自己的位置(Position)。本书不讨论数据元素个数无限的线性表。

         “相同类型”，指的是线性表中的数据元素都属于同一种类型。

 C#实现：

     1接口

      由于现在只考虑线性表的基本操作，所以以C#接口的形式表示线性表，接口中的方法成员表示基本操作。并且，为了使线性表对任何数据类型都适用，数据元素的类型使用泛型的类型参数。在实际创建线性表时，元素的实际类型可以用应用程序中任何方便的数据类型来代替，比如用简单的整型或者用户自定义的更复杂的类型来代替。
       线性表的接口如下所示。

 1 public interface IListDS<T>
 2    {
 3        /**//// <summary>
 4        /// 获取长度
 5        /// </summary>
 6        /// <returns></returns>
 7        int GetLength();
 8
 9        /**//// <summary>
        /// 清空操作
        /// </summary>
        void Clear();

        /**//// <summary>
        /// 判断线性表是否为空
        /// </summary>
        /// <returns></returns>
        bool IsEmpay();

        /**//// <summary>
        /// 附加操作,线性表未满，将值为item的新元素添加到末尾
        /// </summary>
        /// <param name="item"></param>
        void Append(T item);

        /**//// <summary>
        /// 插入操作
        /// </summary>
        /// <param name="item"></param>
        /// <param name="i"></param>
        void Insert(T item,int i);

        /**//// <summary>
        /// 删除操作
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        T Delete(int i);

        /**//// <summary>
        /// 去表元
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        T GetElem(int i);

        /**//// <summary>
        /// 按值查找
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        int Locate(T value);
    }

    2 实现

     实现过程中，算法时间复杂度没有做过多的考虑和计算，有兴趣的朋友可以完成

  1/**//// <summary>
  2    /// 线性表
  3    /// </summary>
  4    /// <typeparam name="T"></typeparam>
  5    public class SeqList<T> : IListDS<T>
  6    {
  7        private int maxsize;  //顺序表的容量
  8        private T[] data;     //数组，用于存储顺序表中的数据元素
  9        private int last;     //指示顺序表最后一个元素的位置
 10
 11        //索引器
 12        public T this[int index]
 13        {
 14            get
 15            {
 16                return data[index];
 17            }
 18            set
 19            {
 20                data[index] = value;
 21            }
 22        }
 23
 24        //最后一个数据元素的位置属性
 25        public int List
 26        {
 27            get
 28            {
 29                return last;
 30            }
 31        }
 32
 33        //容量属性
 34        public int MaxSize
 35        {
 36            get
 37            {
 38                return maxsize;
 39
 40            }
 41            set
 42            {
 43                maxsize = value;
 44            }
 45        }
 46
 47        //构造函数
 48        public SeqList(int size)
 49        {
 50            data = new T[size];
 51            maxsize = size;
 52            last = -1;
 53        }
 54        /**//// <summary>
 55        /// 获取长度
 56        /// </summary>
 57        /// <returns></returns>
 58        public int GetLength()
 59        {
 60            return last + 1;
 61        }
 62
 63        /**//// <summary>
 64        /// 清空操作
 65        /// </summary>
 66        public void Clear()
 67        {
 68            last = -1;        
 69        }
 70
 71
 72        /**//// <summary>
 73        /// 判断线性表是否为空
 74        /// </summary>
 75        /// <returns></returns>
 76        public bool IsEmpay()
 77        {
 78            if (last == -1)
 79            {
 80                return true;
 81            }
 82            else
 83            {
 84                return false;
 85            }
 86        }
 87
 88        /**//// <summary>
 89        /// 判断线性表是否已满
 90        /// </summary>
 91        /// <returns></returns>
 92        public bool IsFull()
 93        {
 94            if (last == maxsize - 1)
 95            {
 96                return true;
 97            }
 98            else
 99            {
                return false;
            }
        }

        /**//// <summary>
        /// 附加操作,线性表未满，将值为item的新元素添加到末尾
        /// </summary>
        /// <param name="item"></param>
      public  void Append(T item)
        {
            if (IsFull())
            {
                Console.Write("list is full");
                return;
            }

            data[++last] = item;
        }

        /**//// <summary>
        /// 插入操作
        /// </summary>
        /// <param name="item"></param>
        /// <param name="i"></param>
        public void Insert(T item, int i)
        {
            if (IsFull())
            {
                Console.Write("List is full");
                return;
            }

            if (i < 1 || i > last + 2)
            {
                Console.Write("Posotion is error");
                return;
            }

            if (i == last + 2)
            {
                data[last + 1] = item;
            }
            else
            {
                for (int j = last; j >= i - 1; --j)
                {
                    data[j + 1] = data[j];
                }
                data[i - 1] = item;
            }
            ++last;
        }

        /**//// <summary>
        /// 删除操作
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        public T Delete(int i)
        {
            T t = default(T);
            if (IsEmpay())
            {
                Console.Write("List is empty!");
                return t;
            }
            if (i < 1 || i > last + 1)
            {
                Console.Write("Position is Error");
                return t;
            }
            if (i == last + 1)
            {
                t = data[last--];

            }
            else
            {
                t = data[i - 1];
                for (int j = i; j <= last; j++)
                {
                    data[j] = data[j + 1];
                }
            }
            --last;
            return t;

        }

        /**//// <summary>
        /// 取表元
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        public T GetElem(int i)
        {
            T t = default(T);
            if (IsEmpay())
            {
                Console.Write("List is Empty");
                return t;
            }

            if (i < 1 || i > last + 1)
            {
                Console.Write("Position is error");
                return t;
            }
            return data[i - 1];

        }

        /**//// <summary>
        /// 按值查找
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public int Locate(T value)
        {
            if (IsEmpay())
            {
                Console.Write("List is empty");
                return -1;
            }

            int i = 0;
            for ( i = 0; i <= last; ++i)
            {
                if (value.Equals(data[i]))
                {
                    break;
                }
            }
            if (i > last)
            {
                return -1;
            }
            return i;
         }
    }

以上代码用C＃实现了线性表的操作，具体的测试没有做，有兴趣的朋友，可以写一个简单的测试程序，

如有问题，请及时告知！谢谢！