范例：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication11
{
class SeqListProgram
{
public class SeqList<T> //: IList<T>
{
private int maxsize; //顺序表的容量
public int Maxsize
{
get { return maxsize; }
}
private T[] data; //数组，用于存储顺序表中的数据元素
private int last; //指示顺序表最后一个元素的位置下标
public int Last
{
get { return last; }
set { last = value; }
}
// 索引器
public T this[int index]
{
get { return data[index]; }
set { data[index] = value; }
}
public SeqList(int size)
{
data = new T[size];
maxsize = size;
last = -1;
}
// 顺序表的长度由于数组是 0 基数组，即数组的最小索引为 0，所以，顺序表的长度就是数
// 组中最后一个元素的索引 last 加 1。
public int GetLength()
{
return last + 1;
}
// 清空
public void Clear()
{
last = -1;
}
public bool IsEmpty()
{
if (last < 0)
{
return true;
}
return false;
}
// 判断顺序表是否已满
public bool IsFull()
{
if (last == maxsize - 1)// 元素下标从0开始
{
return true;
}
return false;
}
// 在顺序表末尾添加新元素
public void Appled(T item)
{
if (!IsFull())
{
data[++last] = item;
}
else
{
Console.WriteLine(" 顺序表已满无法添加 ");
}
}
//在顺序表的第i个数据元素的位置插入一个数据元素
/*
算法的时间复杂度分析：顺序表上的插入操作，时间主要消耗在数据的移动
上，在第i个位置插入一个元素，从ai到an都要向后移动一个位置，共需要移动n-i+1
个元素，而i的取值范围为 1≤i≤n+1，当i等于 1 时，需要移动的元素个数最多，
为n个；当i为n+1 时，不需要移动元素。设在第i个位置做插入的概率为pi，则平
均移动数据元素的次数为n/2。这说明：在顺序表上做插入操作平均需要移动表
中一半的数据元素，所以，插入操作的时间复杂度为O（n）。
*/
public void Insert(T item, int i)
{
if (i < 1 || i > last + 1)
{
Console.WriteLine(" 位置非法 ");
return;
}
if (IsFull())
{
Console.WriteLine(" 顺序表已满无法添加 ");
return;
}
if (i == last + 2)// 判断是不是末尾插入
{
data[last + 1] = item;
}
else
{
// i后面的元素往后移
for (int j = last; j >= i - 1; --j)
{
data[j + 1] = data[j];
}
//将新的数据元素插入到第i-1个位置上
data[i - 1] = item;
}
++last;
}
//删除顺序表的第i个数据元素
/*
而i的取值范围为 1≤i≤n，当i等于 1 时，需要移动
的元素个数最多，为n-1 个；当i为n时，不需要移动元素。设在第i个位置做删除
的概率为pi，则平均移动数据元素的次数为(n-1)/2。这说明在顺序表上做删除操
作平均需要移动表中一半的数据元素，所以，删除操作的时间复杂度为O（n）
*/
public T Delete(int i)
{
T temp = default(T);// default 为泛型代码中的默认关键字
if (IsEmpty())
{
Console.WriteLine("顺序表为空");
return temp;
}
if (i < 1 || i > last + 1)
{
Console.WriteLine(" 位置非法 ");
return temp;
}
if (i == last + 1)
{
data[last--] = temp;
}
else
{
temp = data[i - 1];
for (int j = i; j <= last; ++j)
{
data[j] = data[j - 1];
}
}
--last;
return temp;
}
//获得顺序表的第i个数据元素
public T GetElem(int i)
{
if (IsEmpty() || (i < 1) || (i > last + 1))
{
Console.WriteLine("顺序表为空 or 位置非法!");
return default(T);
}
return data[i - 1];
}
//在顺序表中查找值为value的数据元素
public int Locate(T value)
{
if (IsEmpty())
{
Console.WriteLine("顺序表为空");
return -1;
}
for (int j = 0; j < last; ++j)
{
if (data[j].Equals(value))
{
return j;
}
}
return -1;
}
/*
算法的时间复杂度分析：顺序表中的按值查找的主要运算是比较，比较的次
数与给定值在表中的位置和表长有关。当给定值与第一个数据元素相等时，比较
次数为 1；而当给定值与最后一个元素相等时，比较次数为 n。所以，平均比较
次数为(n+1)/2，时间复杂度为 O（n）
*/
public void Reverse()
{
T temp = default(T);
int len = GetLength();
for (int i = 0; i <= len >> 1; ++i)
{
temp = data[i];
data[i] = data[len - i];
data[len - i] = temp;
}
}
}
static void Main(string[] args)
{
SeqList<string> Sl = new SeqList<string>(3);
Sl.Appled("str1");
Sl.Appled("str2");
Sl.Appled("str3");
Console.WriteLine("{0}", Sl.GetLength());
Console.WriteLine("{0}", Sl.GetElem(2));
// string Del_item = Sl.Delete(3);
Console.WriteLine("{0}", Sl[0]);
Console.WriteLine("{0}", Sl.GetLength());
SeqList<string> S2= new SeqList<string>(7);
Console.WriteLine( S2.Maxsize);
Console.ReadLine();
}
}
}
