顺序表

线性表是最常用且最简单的一种数据结构。简言之，一个线性表是n个数据元素的有限序列。线性表的顺序表示指的是一组地址连续的存储单元依次存储线性表的数据元素。线性表的顺序存储结构是一种随机存取的存储结构。

由于c#中的数组类型也有随机存取的特性，因此，通常采用数组来描述数据结构中的顺序存储结构。

为了能够复用代码，采用泛型类的设计。

这里要说明以下，由于.NET提供的关于线性表的类(如：ArrayLIst,SortedList)采用下标从0开始的索引值设计。所以，为了学习使用方便。以下代码中，关于“第i个”元素，都是从0开始算起的。

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

namespace 线性表
{
    public class SeqList<T> where  T:IComparable<T>
    {
     
        private int length;                     //线性表表的当前长度
        private const int INITIAL_SIZE = 10;    //线性表存储空间的初始分配量
        private const int LIST_INCREMENT = 5;   //线性表存储空间的分配增量
        private int listSize;                   //当前分配的存储容量
        private T[] lists;                      //数组,用于存储数据

        #region 构造函数

        public SeqList()
        {
            lists = new T[INITIAL_SIZE];
            this.length = 0;
            this.listSize = INITIAL_SIZE;
        }

        public SeqList(int size)
        {
            if (size < 0)
            {
                throw new ArgumentException("ArgumentException:线性表长度不能小于0.");
            }
            lists = new T[size];
            this.length = 0;
            this.listSize = size;
        }
        #endregion

        #region 属性和索引器

        //线性表长度Length属性
        public int Length
        {
            get { return length; }
        }

        //线性表容量Capacity属性
        public int Capacity
        {
            get { return listSize; }
        }

        //索引器,可以使像使用数组一样引用线性表中的元素
        public T this[int index]
        {
            get { return lists[index]; }
            set { lists[index] = value; }
        }
        #endregion

        /// <summary>
        /// 如果线性表容量不够用，增加容量。
        /// </summary>
        private void enlargeIfFull()
        {
            if (this.length == this.listSize)
            {
                int bigger = length + LIST_INCREMENT;
                this.listSize = bigger;

                T[] moreLists = new T[bigger];
                this.lists.CopyTo(moreLists, 0);   //复制元素到新的数组

                this.lists = moreLists;            //指向新的数组
            }
        }

        #region 顺序表常规操作
        /// <summary>
        /// 获取线性表长度
        /// </summary>
        /// <returns>长度</returns>
        public int GetLength()
        {
            return this.length;
        }

        /// <summary>
        /// 清空线性表
        /// </summary>
        public void Clear()
        {
            this.length = 0;
        }

        /// <summary>
        /// 判断是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return length == 0;
        }

        /// <summary>
        /// 添加操作，在末尾添加元素
        /// </summary>
        /// <param name="item">需要添加的元素</param>
        public void Add(T item)
        {
            enlargeIfFull();

            lists[length++] = item;
        }

        /// <summary>
        /// 插入操作，i为从0开始的索引值
        /// </summary>
        /// <param name="i">索引值，从0开始</param>
        /// <param name="item">插入的元素</param>
        public void Insert(int i, T item)
        {
            if (i < 0 || i > this.length)
            {
                throw new ArgumentException("ArgumentException:参数不合法,无法执行插入操作");
            }

            enlargeIfFull();

            for (int j = this.length - 1; j >= i; j--)  
            {
                lists[j + 1] = lists[j];    //插入位置及之后的元素后移
            }

            lists[i] = item;                //插入item
            this.length++;                  //表长增1

        }

        /// <summary>
        /// 删除操作
        /// </summary>
        /// <param name="i">索引值，从0开始</param>
        /// <returns></returns>
        public T Delete(int i)
        {
            if (i < 0 || i > this.length-1)
            {
                throw new ArgumentException("ArgumentException:参数不合法,无法执行删除操作");
            }

            T del = lists[i];           //被删除元素赋值给del

            for (int j = i; j < this.length - 1; j++)
            {
                lists[j] = lists[j + 1];    //被删除元素之后的元素前移
            }

            this.length--;                  //表长减1
            return del;                     //返回被删除元素
        }

        /// <summary>
        /// 获取元素，该方法与索引器效果相同
        /// </summary>
        /// <param name="i">索引值，从0开始</param>
        /// <returns>元素值</returns>
        public T GetElem(int i)
        {
            if (i < 0|| i > this.length-1)
            {
                throw new ArgumentException("ArgumentException:参数不合法,无法获取元素");
            }

            return lists[i];
        }

        /// <summary>
        /// 定位元素位置，相当于IndexOf方法
        /// </summary>
        /// <param name="item">元素</param>
        /// <returns>索引值，从0开始</returns>
        public int Locate(T item)
        {
            int i = 0;                      //i的初始值为第0个元素的位置

            while (i < this.length && !item.Equals(lists[i]))
            {
                i++;
            }

            if (i <=this.length-1)
                return i;
            else
                return -1;

        }

        /// <summary>
        /// 倒置操作
        /// </summary>
        public void Reverse()
        {
            if (this.length == 0)
            {
                throw new InvalidOperationException("InvalidOperationException:线性表为空，无法执行倒置操作");
            }

            int i = 0;
            int j = this.length / 2;
            while (i < j)
            {
                T tmp = lists[i];
                lists[i] = lists[this.length-1- i];
                lists[this.length-1- i] =tmp;
                i++;
            }
        }

        /// <summary>
        /// 合并操作，前提条件是当前线性表和other线性表按非递减有序排列
        /// </summary>
        /// <typeparam name="TItem">泛型</typeparam>
        /// <param name="other">另外一个线性表</param>
        /// <returns>合并后的线性表</returns>
        public SeqList<T> Merge<TItem>(SeqList<T> other) where TItem:T
        {
            SeqList<T> sList = new SeqList<T>();
            int i = 0;                      //当前线性表的循环变量
            int j = 0;                      //other线性表的循环变量
            while (i <= this.length - 1 && j <= other.length - 1)
            {
                if (lists[i].CompareTo(other[j]) < 0 || lists[i].CompareTo(other[j]) == 0)
                {
                    sList.Add(lists[i++]);
                }
                else
                {
                    sList.Add(other[j++]);
                }
            }

            while (i <= this.length - 1)
            {
                sList.Add(lists[i++]);
            }
            while (j <= other.length-1)
            {
                sList.Add(other[j++]);
            }
            return sList;
        }

        /// <summary>
        ///并集操作,将当前线性表表中没有，other中有的元素插入表末尾
        /// </summary>
        /// <param name="other"></param>
        public void Union(SeqList<T> other)
        {
            int len = this.length;
            for (int i = 0; i < other.length; i++)
            {
                T tmp =other[i];
                if (this.Locate(tmp) == -1)
                {
                    this.Insert(len++, tmp);
                }

            }
        }
        #endregion

    }
}