C#数据结构-顺序表

顺序表，顾名思义存储在计算机指定内存区域的一块连续的存储结构，跟我们一起排队做广播体操的那种方式

存储物理结构：物理内存空间上是连续的

存储逻辑关系：存储值之间的关系为一对一

使用场景：一般访问数据量比较大，新增和删除操作不频繁的数据

那么我们这里实现的语言是用的c#，对于线性表的一些特性我们这里用数组来操作这个实现和操作。这里我们对线性表做一些操作：增、删、改、查

首先我们来定义一个顺序表

class LineClass
    {
        //设置线性表最大长度
        public const int MaxSize = 100;
        //初始化数据
        public string[] data;
        //线性表长度
        public int length;
        //初始化构造
        public LineClass()
        {
            //构造函数初始化线性表
            data = new string[MaxSize];
            length = 0;
        }
}

接下来我们把建立数据存储元素结构，这里是循环插入线性表，时间空间复杂度为: O(n)

#region 存储元素结构  O(n)
        public void CreateLine(string[] splits)
        {
            int i;
            for (i = 0; i < splits.Length; i++)
            {
                data[i] = splits[i];
            }

            length = i;
        }
        #endregion

然后我们把这个建立打印这个线性表的方法 ，时间空间复杂度为: O(n)

#region 将线性表的元素构成一个字符串返回  O(n)
        public string DispLine()
        {
            string strLine = string.Empty;
            for (int i = 0; i < length; i++)
            {
                strLine += data[i] + ",";
            }
            return length > 0 ? strLine.TrimEnd(',') : "";

        }
        #endregion

获取这个顺序表的长度。时间空间复杂度为： O(1)

#region 线性表的长度    O(1)
        public int LineLength()
        {
            return length;
        }
        #endregion

获取第item个元素的值，时间空间复杂度为： O(1)

#region 获取线性表第item项，元素值为e   O(1)
        public bool GetElem(int item, ref string e)
        {
            if (item < 1 || item > length)
            {
                return false;
            }

            e = data[item - 1];
            return true;
        }
        #endregion

根据值获取到item的位置，这里值得注意的是，如果顺序表里存在两个相同的值，到底获取哪一个呢，我们这里是获取从第一个元素开始最近的一个值，如果匹配，那么返回。时间空间复杂度为： O(n)

#region 根据值获取位置   O(n)
        public int LocateElem(string e)
        {
            int i = 0;
            while (i= length ? 0 : i + 1;
        }
        #endregion

接下来就是新增一个值，插入一个值后面值的往后排一个单位，记录最新的顺序表元素的数量。

注意：这里分为三种情况，第一种从第一个位置插入，那么后面所有的元素往后移动一个单位。这里的时间空间复杂度为：O(n)
第二种从中间插入，跟第一种的情况差不多，从这个位置开始，后面的每一项元素往后移动一个单位

第三种情况就是在顺序表后面插入，这种情况就直接插入。这里的时间复杂度为：O(1)

所有这里分为最好的和最坏的情况

#region 插入，从item处插入e值 O(n)
        public bool LineInsert(int item, string e)
        {
            //插入的时候小于第一个的位置，或者大于最后两个位置
            if (item<1 || item>length+1)
            {
                return false;
            }
            for (int j = length; j > item; j--)
            {
                data[j] = data[j-1];
            }

            data[item - 1] = e;
            length++;
            return true;
        }
        #endregion

最后就是删除操作，跟新增差不多，只不过这里是删除，删除后此节点后面的所有元素向前移动一个单位，这里的时间空间复杂度为： O(n)

#region 删除  O(n)
        public bool LineDelete(int item, string e)
        {
            //删除的时候小于第一个的位置，或者大于最后一个位置
            if (item < 1 || item > length )
            {
                return false;
            }
            e = data[item];
            for (int i = 0; i < length-1; i++)
            {
                data[i] = data[i + 1];
            }
            length--;
            return true;
        }
        #endregion

结论：那么到这里呢顺序表操作结束了，可以说顺序表是结构最简单，存储内存消耗最小的一个数据结构
优点： 存储密度高，存储效率高，存取速度快，可以随机存取结点。

缺点：长度为定值，中途不易扩充。插入或删除需要移动结点，修改效率低。