数据结构-02 _用顺序表解决线性表的编程问题

看到这个标题，相必最先应该只到什么是顺序表，什么是线性表。

线性表(linear list)：由n(n>=0)个相同的数据类型的数据元素（结点）a0,a1,a2,...an-1 组成的有限序列。

顺序表：把线性表的结构按照逻辑顺序存放在一组地址连续的存储单元里，用这种方式存储的线性表简称顺序表。

线性表的基本操作：

　　1.初始化操作

　　2.插入操作：InsertNode(T a,int i) 在线性表的第i个位置插入一个值为a的新元素，使得原序号为i，i+1，...，n 的数据元素的序号变成i+1，i+2，... n+1，插入后表长=原表长+1.

　　3.删除操作：DeleteNode(int i) 在线性表中删除序号为i的数据元素，返回删除后的数据元素。使得原序号i+1，i+2，... n的数据元素序号变成i，i+1，...，n-1，删除后的表长=原表长-1.

　　4.取表元素：SearchNode(int i) 获取线性表中第i个数据元素。

　　5.定位元素：SearchNode(T value) 在线性表中查找值为value的数据元素，返回线性表首次出现value值得序号。

　　6.求线性表长度：GetLength()

　　7.清空线性表:Clear()

　　8.判断线性表是否为空 IsEmpty()

根据上面线性表的操作我们可以定义操作线性表的接口了：

interface IlinarList<T>
{
   //插入元素
   void InsertNode(T a, int i);
   //删除元素
   void DeleteNode(int i);
   //查找表元素
   T SearchNode(int i);
   //定位元素
   T SearchNode(T value);
   //求表长度
   int GetLength();
   //清空操作
   void Clear();
   //判断线性表是否为空
　　bool IsEmpty();
}

在顺序表中实现这个接口：

public class SeqList<T> : IlinarList<T>
    {
        /// <summary>
        /// 顺序表的最大容量
        /// </summary>
        private int maxsize{get;set;}
        /// <summary>
        /// 数组，存储顺序表中的数据元素
        /// </summary>
        private T[] data;
        /// <summary>
        /// 顺序表的实际长度
        /// </summary>
        private int length { get; set; }

        /// <summary>
        /// 初始化线性表
        /// </summary>
        /// <param name="size"></param>
        public SeqList(int size)
        {
            maxsize = size;
            data = new T[maxsize];
            length = 0;
        }
        //在顺序表的末尾追加数据元素
        public void InsertNode(T a)
        {
            if (IsFull())
            {
                Console.WriteLine("顺序表已满!");
                return;
            }
            data[length] = a;
            length++;
        }
        //在顺序表的第i个数据元素的位置插入一个数据元素
        public void InsertNode(T a, int i)
        {
            if (IsFull())
            {
                Console.WriteLine("顺序表已满!");
                return;
            }
            if (i < 1 || i > length + 1)
            {
                Console.WriteLine("Position is error!");
                return;
            }
            else
            {
                for (int j = length - 1; j >= i - 1; j--)
                {
                    data[j + 1] = data[j];
                }
                data[i - 1] = a;
            }
            length++;
        }
        //删除顺序表的第i个元素
        public void DeleteNode(int i)
        {
            if (IsEmpty())
            {
                Console.WriteLine("顺序表为空!");
                return;
            }
            if (i < 1 || i > length + 1)
            {
                Console.WriteLine("Position is error!");
                return;
            }
            for (int j = i; j < length; j++)
            {
                data[j - 1] = data[j];
            }
            length--;
        }
        //获取顺序表第i个数据元素
        public T SearchNode(int i)
        {
            if (IsEmpty() || (i < 1) || (i > length))
            {
                Console.WriteLine("List is empth or Position is error!");
                return default(T);
            }
            return data[i - 1];
        }
        //在顺序表中查找值为value的数据元素
        public T SearchNode(T value)
        {
            if (IsEmpty())
            {
                Console.WriteLine("List is Empty!");
                return default(T);
            }
            int i = 0;
            for(i=0;i<length;i++)
            {
                if (data[i].ToString().Contains(value.ToString()))
                {
                    break;
                }
            }
            if (i >= length)
            {
                return default(T);
            }
            return data[i];

        }
        //求顺序表的长度
        public int GetLength()
        {
            return length;
        }
        //清空顺序表
        public void Clear()
        {
            length = 0;
        }
        //判断顺序表是否为空
        public bool IsEmpty()
        {
            if (length == 0)
            {
                return true;
            }
            else return false;
        }
        //判断顺序表是否为满
        public bool IsFull()
        {
            if (length == maxsize)
            {
                return true;
            }
            else return false;
        }

    }

用顺序表是实现这些操作还是比较简单的，我们也可以把这些用到实际的解决问题当中去。

我将会写一个实际的应用场景.....