线性表（顺序结构实现）

线性表（顺序结构实现）

背景

今天来复习 以数组这种顺序结构 实现的线性表

基本理论

线性表的定义以及实现的操作如下：

代码实现

• 首先定义一个接口，来定义线性表的可进行的操作

/// <summary>
/// 线性表接口，定义操作
/// </summary>
/// <typeparam name="T"></typeparam>
public interface ILinearList<T> where T : IComparable<T>
    {
        int Length { get; }
        T this[int index] { get; set; }

        void Clear();
        void Insert(int index, T data);
        bool IsEmpty();
        void Remove(int index);
        int Search(T data);
    }

• 接下来，在类体中定义顺序结构实现的线性表的各种操作的具体实现：

（在实现的时候要注意 边界条件，使程序更加健壮）

/// <summary>
/// 顺序线性表
/// </summary>
/// <typeparam name="T">线性表存储数据类型</typeparam>
public class SeqList<T> : ILinearList<T> where T : IComparable<T>
{
        /// <summary>
        /// 数组实现线性表
        /// </summary>
        private T[] _dataset;

        /// <summary>
        /// 返回线性表元素个数
        /// </summary>
        public int Length { get; private set; }

        /// <summary>
        /// 获取或设置线性表对应索引处的数据
        /// </summary>
        /// <param name="index">索引</param>
        /// <returns>对应索引处数据</returns>
        public T this[int index]
        {
            get
            {
                if (index < 0 || index > Length -1)
                    throw new IndexOutOfRangeException();
                return _dataset[index];
            }
            set
            {
                if (index < 0 || index > Length - 1)
                    throw new IndexOutOfRangeException();
                _dataset[index] = value;
            }
        }

        /// <summary>
        /// 获取线性表最大存储元素个数
        /// </summary>
        public int MaxSize { get; }

        /// <summary>
        /// 构造函数，初始化顺序线性表
        /// </summary>
        /// <param name="max"></param>
        public SeqList(int max)
        {
            if (max <= 0)
                throw new ArgumentOutOfRangeException(nameof(max));
            MaxSize = max;
            _dataset = new T[MaxSize];
            Length = 0;
        }

        /// <summary>
        /// 判断顺序线性表是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return Length == 0;
        }

        /// <summary>
        /// 清空顺序线性表
        /// </summary>
        public void Clear()
        {
            Length = 0;
        }

        /// <summary>
        /// 在顺序线性表对应索引处插入数据
        /// </summary>
        /// <param name="index"></param>
        /// <param name="data"></param>
        public void Insert(int index, T data)
        {
            if (index < 0 || index > Length)
                throw new IndexOutOfRangeException();
            if (Length == MaxSize)
                throw new Exception("线性表已满");
            for (int i = Length; i > index; i--)
            {
                _dataset[i] = _dataset[i - 1];
            }
            _dataset[index] = data;
            Length++;
        }

        /// <summary>
        /// 移除顺序线性表对应索引处的元素
        /// </summary>
        /// <param name="index"></param>
        public void Remove(int index)
        {
            if (index < 0 || index > Length - 1)
                throw new IndexOutOfRangeException();
            for (int i = index; i < Length - 1; i++)
            {
                _dataset[i] = _dataset[i + 1];
            }
            Length--;
        }

        /// <summary>
        /// 查找顺序线性表中是否有对应元素
        /// </summary>
        /// <param name="data">待查找元素</param>
        /// <returns>若有，返回该元素索引，若无，返回-1</returns>
        public int Search(T data)
        {
            int i;
            for (i = 0; i < Length; i++)
            {
                if (_dataset[i].CompareTo(data) == 0)
                    break;
            }
            return i == Length ? -1 : i;
        }
    }