C#顺序表底层实现

  顺序表的底层实现容易在面试题中出现,这里我先写了一个顺序表的泛型接口IList,声明了几个顺序表常用的增删改查功能,然后在MySequenceList类中对这些基本功能进行实现,如有不足之处请各位网友指正.
  不多说,直接上代码:
  IList接口类:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
/// <summary>
/// 模拟List方法的底层
/// </summary>
namespace DataStruct
{
    interface IList<T>
    {
        /// <summary>
        /// 添加数据的功能
        /// </summary>
        /// <param name="item"></param>
        void Add(T item);

        /// <summary>
        /// 将元素插入到指定下标的功能
        /// </summary>
        /// <param name="index"></param>
        /// <param name="value"></param>
        void Insert(int index, T value);

        /// <summary>
        /// 获取顺序表中元素个数的功能
        /// </summary>
        int GetCount();

        /// <summary>
        ///获取顺序表容量的功能
        /// </summary>
        int GetCapacity();

        /// <summary>
        /// 清空数据的功能
        /// </summary>
        void Clear();

        /// <summary>
        /// 针对下标删除数据的功能
        /// </summary>
        /// <param name="index"></param>
        void RemoveAt(int index);

        /// <summary>
        /// 对某下标的元素进行更改的功能
        /// </summary>
        /// <param name="index"></param>
        /// <param name="value"></param>
        void Replace(int index, T value);


        /// <summary>
        /// 根据值获取下标的功能
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        int GetIndex(T value);

        /// <summary>
        /// 根据下标获取该元素的值的功能
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        T GetValue(int index);

        /// <summary>
        /// 判断数据是否已满的功能
        /// </summary>
        /// <returns></returns>
        bool IsPull();

        /// <summary>
        /// 判断数据是否为空的功能
        /// </summary>
        /// <returns></returns>
        bool IsEmpty();
    }
}

  功能实现类MySequenceList:

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

namespace DataStruct
{
    class MySequenceList<T> : IList<T>
    {
        private int maxSize;//当前顺序表的最大容量
        private int lastIndex;//当前顺序表最后一位元素的下标
        private T[] myData;//存储数据的数组

        /// <summary>
        /// 构造函数,强制性要求new对象的时候给初始容量
        /// </summary>
        /// <param name="size"></param>
        public MySequenceList(int size)
        {
            myData = new T[size];
            maxSize = size;
            lastIndex = -1;
        }

        /// <summary>
        /// 添加数据的方法
        /// </summary>
        /// <param name="item"></param>
        public void Add(T item)
        {
            //当顺序表中数据已满时
            if (IsPull())
            {
                Console.WriteLine("顺序表中元素已满,无法添加新的元素");
            }
            else
            {
                lastIndex += 1;
                myData[lastIndex] = item;
            }

        }

        /// <summary>
        /// 在指定下标删除元素的方法
        /// </summary>
        /// <param name="index"></param>
        public void RemoveAt(int index)
        {
            //删除位置不对时
            if (index < 0 || index > lastIndex)
            {
                Console.WriteLine("删除位置不正确");
                return;
            }
            //当顺序表中的元素只有一个时
            if (maxSize == 1 && index == 0)
            {
                lastIndex = -1;
                return;
            }
            //当所要删除的元素为最后一个时
            if (index == lastIndex)
            {
                lastIndex -= 1;
                return;
            }
            //一般情况下
            else
            {
                for (int j = index; j < lastIndex; j++)
                {
                    myData[j] = myData[j + 1];
                }
                lastIndex--;
            }
        }

        /// <summary>
        /// 清空数据的方法
        /// </summary>
        public void Clear()
        {
            lastIndex = -1;
        }

        /// <summary>
        /// 根据元素下标获取该元素值的方法
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T GetValue(int index)
        {
            return myData[index];
        }

        /// <summary>
        /// 根据元素的值获取满足其值的顺序表中第一个元素的下标的方法
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public int GetIndex(T value)
        {
            //顺序表为空时
            if (IsEmpty())
            {
                Console.WriteLine("该顺序表为空");
            }
            int j = 0;
            //顺序表不为空时
            for (int i = 0; i < lastIndex + 1; i++)
            {
                if (value.Equals(myData[i]))
                {
                    j = i;
                    break;
                }
            }
            return j;
        }

        /// <summary>
        /// 根据下标对元素进行修改的方法
        /// </summary>
        /// <param name="index"></param>
        /// <param name="value"></param>
        public void Replace(int index,T value)
        {
            myData[index] = value;
        }

        /// <summary>
        /// 把某个元素插入到某个下标的方法
        /// </summary>
        /// <param name="index"></param>
        /// <param name="value"></param>
        public void Insert(int index, T value)
        {
            if (IsPull())
            {
                Console.WriteLine("顺序表已满,无法插入");
            }
            if (index < 0 || index > lastIndex + 1)
            {
                Console.WriteLine("插入位置不对");
            }
            else
            {
                for (int i = lastIndex + 1; i > index; i--)
                {
                    myData[i] = myData[i - 1];
                }
                myData[index] = value;
            }
            lastIndex += 1;
        }

        /// <summary>
        /// 获取此顺序表容量的方法
        /// </summary>
        /// <returns></returns>
        public int GetCapacity()
        {
            return maxSize;
        }

        /// <summary>
        /// 获取元素数量的方法
        /// </summary>
        /// <returns></returns>
        public int GetCount()
        {
            return lastIndex + 1;
        }
           
        /// <summary>
        /// 判断是否为空的方法
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return lastIndex == -1;
        }

        /// <summary>
        /// 判断是否已满的方法
        /// </summary>
        /// <returns></returns>
        public bool IsPull()
        {
            return maxSize == lastIndex + 1;
        }
    }
}

  Program测试

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

namespace DataStruct
{
    class Program
    {
        static void Main(string[] args)
        {
            MySequenceList<int> mySeq = new MySequenceList<int>(6);

            //增加方法的测试
            mySeq.Add(1);
            mySeq.Add(2);
            mySeq.Add(3);
            mySeq.Add(4);
            mySeq.Add(5);

            //删除方法的测试
            mySeq.RemoveAt(0);

            //元素更改方法的测试
            mySeq.Replace(1, 888);

            //元素插入方法的测试
            mySeq.Insert(4, 520);

            //元素清空方法的测试
            mySeq.Clear();

            //元素获取方法的测试
            for (int i = 0; i < mySeq.GetCount(); i++)
            {
                Console.WriteLine("此顺序表中第{0}个数是:" + mySeq.GetValue(i),i);              
            }
            Console.WriteLine("元素是否为空:" + mySeq.IsEmpty());
            Console.WriteLine("元素是否已满:" + mySeq.IsPull());
            Console.ReadLine();
        }
    }
}