>之--线性表的顺序存储(顺序表) (转)

　线性表是线性存储结构中比较简单的一种结构.线性表是线性结构的抽象,线性表中的各个元素是一对一的线性关系,这种一对一的关系是位置关系,即:除第一个元素外,其他元素只有一个前驱;除最后一个元素外,其他元素只有一个后继;

　　线性表的存储分为:顺序存储和链式存储,顺序存储是指用地址连续的存储单元依次存储线性表中的各个元素,用这种方式存储的线性表称为顺序表;链式存储是指用一组任意的存储单元(地址可以是连续的,也可以是不连续的)来存储线性表中的各个元素,用这种方式来存储的线性表称为链表;

     下面是顺序表的C#实现:

　　首先,定义用一个接口IListDS<T>定义线性表上的操作:

　　代码:

 

Code
    interface IListDS<T>
    {
        /// <summary>
        /// 获取线性表长度
        /// </summary>
        int GetLength();
        /// <summary>
        /// 清空线性表
        /// </summary>
        void Clear();
        /// <summary>
        /// 线性表是否已满
        /// </summary>
        /// <returns></returns>
        bool IsFull();
        /// <summary>
        /// 线性表是否是空
        /// </summary>
        /// <returns></returns>
        bool IsEmpty();
        /// <summary>
        /// 附加项目
        /// </summary>
        /// <param name="item"></param>
        void Append(T item);
        /// <summary>
        /// 删除第i个元素
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        T Delete(int i);
        /// <summary>
        /// 在第i个元素的位置插入一个项目
        /// </summary>
        /// <param name="item"></param>
        /// <param name="i"></param>
        void Insert(T item, int i);
        /// <summary>
        /// 取表元
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        T GetElem(int i);
        /// <summary>
        /// 按值查找
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        int Locate(T item);
        /// <summary>
        /// 反转
        /// </summary>
        void Reverse();
    }

 　　其次,定义顺序表:

 

 

Code
 /// <summary>
    /// 顺序表
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class SeqList<T>:IListDS<T>
    {
        private T[] _data;     //存储数据元素的数组
        private int _maxLength;//最大容量

        /// <summary>
        /// 索引器
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T this[int index]
        {
            get
            {
                if (IsEmpty())
                {
                    Console.WriteLine("顺序表为空");
                    return default(T);
                }
                if (index < 0 || index > _last)
                {
                    Console.WriteLine("索引超出边界");
                    return default(T);
                }
                return _data[index];
            }
            set
            {
                if (IsEmpty())
                {
                    Console.WriteLine("顺序表为空");
                    return;
                }
                if (index < 0 || index > _last)
                {
                    Console.WriteLine("索引超出边界");
                    return;
                }
                _data[index] = value;
            }
        }
        /// <summary>
        /// 最大长度
        /// </summary>
        public int MaxLength
        {
            get { return _maxLength; }
            set { _maxLength = value; }
        }
        private int _last;     //最后一个元素的位置
        /// <summary>
        /// 最后一个元素的位置
        /// </summary>
        public int Last
        {
            get { return _last; }
        }

        /// <summary>
        /// 顺序表构造函数
        /// </summary>
        /// <param name="maxLength"></param>
        public SeqList(int maxLength)
        {
            _data = new T[maxLength];
            _maxLength = maxLength;
            _last = -1;
        }

        #region IListDS<T> 成员
        /// <summary>
        /// 获取顺序表的长度
        /// </summary>
        public int GetLength()
        {
            return _last + 1;
        }
        /// <summary>
        /// 清空顺序表
        /// </summary>
        public void Clear()
        {
            _last = -1;
        }
        /// <summary>
        /// 判断顺序表是否已满
        /// </summary>
        /// <returns></returns>
        public bool IsFull()
        {
            if (_last == _maxLength - 1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 判断顺序表是否为空
        /// </summary>
        /// <returns>True为空,Fals为非空</returns>
        public bool IsEmpty()
        {
            if (_last == -1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 附加项目到最后位置
        /// </summary>
        /// <param name="item"></param>
        public void Append(T item)
        {
            if (IsFull())
            {
                Console.WriteLine("顺序表已满");
                return;
            }
            _data[++_last] = item;
        }

        /// <summary>
        /// 删除第i个元素,并将其返回
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        public T Delete(int i)
        {
            T temp = default(T);
            if (IsEmpty())
            {
                Console.WriteLine("顺序表为空");
                return default(T);
            }
            if (i < 1 || i > _last + 1)
            {
                Console.WriteLine("位置错误");
                return default(T);
            }
            if (i == _last + 1)
            {
                temp = _data[_last--];
                return temp;
            }
            else
            {
                temp = _data[i-1];
                for (int j = i - 1; j < _last; ++j)
                {
                    _data[j] = _data[j + 1];
                }
            }
            --_last;  //修改表长
            return temp;
        }

        /// <summary>
        /// 向顺序表第i个元素位置插入一个数据元素
        /// </summary>
        /// <param name="item"></param>
        /// <param name="i"></param>
        public void Insert(T item, int i)
        {
            if (IsFull())
            {
                Console.WriteLine("顺序表已满");
                return;
            }
            if (i < 1 || i > _last + 2)
            {
                Console.WriteLine("位置错误");
                return;
            }
            if (i == _last + 2)
            {
                _data[i - 1] = item;
            }
            else
            {
                for (int j = _last;j>=i-1;--j)
                {
                    _data[j+1] = _data[j];
                }
                _data[i - 1] = item;
            }
            ++_last;
        }

        /// <summary>
        /// 获取顺序表第i个数据元素
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        public T GetElem(int i)
        {
            if (IsEmpty() || i < 1 || i > _last+1)
            {
                Console.WriteLine("顺序表为空或位置出错");
                return default(T);
            }
            return _data[i-1];
        }
        /// <summary>
        /// 获取顺序表中值为item的数据元素的索引
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public int Locate(T item)
        {
            if (IsEmpty())
            {
                Console.WriteLine("顺序表为空");
                return -1;
            }
            int i = 0;
            for (i = 0; i <= _last; ++i)
            {
                if (item.Equals(_data[i]))
                    break;
            }
            if (i > _last) //如果不存在与给定元素相等的元素
            {
                return -1;
            }
            return i;
        }

        public void Reverse()
        {
            T temp = default(T);
            for (int i = 0; i < (_last+1)/ 2; ++i)
            {
                temp = _data[i];
                _data[i] = _data[_last - i];
                _data[_last - i] = temp;
            }
        }

        #endregion
    }

     对顺序表的一些算法:

 

 

Code
/// <summary>
        /// 精简顺序表
        /// </summary>
        /// <param name="L"></param>
        /// <returns></returns>
        static SeqList<int> Purge(SeqList<int> L)
        {
            SeqList<int> result = new SeqList<int>(L.MaxLength);
            result.Append(L[0]);
            for (int i = 0; i < L.GetLength(); i++)
            {
                int j = 0;
                for (j = 0; j < result.GetLength(); j++)
                {
                    if (L[i] == result[j])
                        break;
                }
                if (j >= result.GetLength())
                {
                    result.Append(L[i]);
                }
            }
            return result;
        }

        /// <summary>
        /// 合并连个顺序表
        /// </summary>
        /// <param name="la"></param>
        /// <param name="lb"></param>
        /// <returns></returns>
        static SeqList<int> Merge(SeqList<int> la, SeqList<int> lb)
        {
            int len1 = la.GetLength();
            int len2 = lb.GetLength();
            int totalLength = len1+len2;
            SeqList<int> result = new SeqList<int>(totalLength);

            int i=0;
            int j=0;
            while (i < len1 && j < len2)
            {
                if (la[i] < lb[j])
                {
                    result.Append(la[i]);
                    i++;
                }
                else
                {
                    result.Append(lb[j]);
                    j++;
                }
            }
            while (i < len1)
            {
                result.Append(la[i++]);
            }
            while (j < len2)
            {
                result.Append(lb[j++]);
            }
            return result;
        }

 

 

日子就是问题叠着问题，要挺胸抬头去面对！