线性表——顺序表

关于基础的概念东西我就不写了，你可以去查资料

先来定义一个接口

 

 1/**//*----------------------------------------------------------------
 2// Copyright (C) 2008 NoCompany
 3// 版权所有。 
 4//
 5// 文件名：IListDS.cs
 6// 文件功能描述：定义一个顺序表要实现的一般功能
 7//----------------------------------------------------------------*/
 8using System;
 9using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DataStructure
{
    /**//// <summary>
    /// 基于泛型的顺序表要实现的一般功能借口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IListDS<T>
    {

        /**//// <summary>
        /// 得到长度
        /// </summary>
        /// <returns>顺序表的长度</returns>
        int GetLength();

        /**//// <summary>
        /// 清空顺序表
        /// </summary>
        void Clear();

        /**//// <summary>
        /// 末尾附加
        /// </summary>
        /// <param name="item">附加元素</param>
        void Append(T item);

        /**//// <summary>
        /// 插入操作
        /// </summary>
        /// <param name="item">插入的元素</param>
        /// <param name="position">插入位置</param>
        void Insert(T item, int position);

        /**//// <summary>
        /// 删除操作
        /// </summary>
        /// <param name="i">删除元素的位置</param>
        /// <returns>被删除的元素</returns>
        T Delete(int position);

        /**//// <summary>
        /// 得到表中指位置的元素
        /// </summary>
        /// <param name="position">元素位置</param>
        /// <returns>此位置的元素</returns>
        T GetElement(int position);

        /**//// <summary>
        /// 按元素查找
        /// </summary>
        /// <param name="value">元素</param>
        /// <returns>元素的位置</returns>
        int Locate(T value);

    }
}

 

 顺序表类SeqList

  1/**//*----------------------------------------------------------------
  2// Copyright (C) 2008 NoCompany
  3// 版权所有。 
  4// 文件名：IListDS.cs
  5// 文件功能描述：定义一个顺序表类
  6//----------------------------------------------------------------*/
  7using System;
  8using System.Collections.Generic;
  9using System.Linq;
 10using System.Text;
 11
 12namespace DataStructure
 13{
 14
 15    /**//// <summary>
 16    /// 基于泛型的顺序表类
 17    /// </summary>
 18    /// <typeparam name="T">泛型对象</typeparam>
 19    public class SeqList<T>:IListDS<T>
 20    {
 21
 22        Fields#region Fields
 23        
 24        /**//// <summary>
 25        /// 容量
 26        /// </summary>
 27        private int maxsize;
 28
 29        /**//// <summary>
 30        /// 数据元素
 31        /// </summary>
 32        private T[] data;
 33
 34        /**//// <summary>
 35        /// 最后一个元素的位置
 36        /// </summary>
 37        private int last;
 38
 39        /**//// <summary>
 40        /// 是否已满
 41        /// </summary>
 42        private bool isFull;
 43
 44        /**//// <summary>
 45        /// 是否为空
 46        /// </summary>
 47        private bool isEmpty;
 48
 49        #endregion
 50
 51        Properity#region Properity
 52
 53        /**//// <summary>
 54        /// <value>顺序表的容量</value>
 55        /// </summary>
 56        public int Maxsize
 57        {
 58            get { return maxsize; }
 59            set { maxsize = value; }
 60        }
 61
 62        /**//// <summary>
 63        /// <value>索引器</value>
 64        /// </summary>
 65        /// <param name="index">索引号</param>
 66        /// <returns>元素</returns>
 67        public T this[int index]
 68        {
 69            get
 70            {
 71                return data[index];
 72            }
 73            set
 74            {
 75                data[index] = value;
 76            }
 77        }
 78
 79        /**//// <summary>
 80        /// <value>最后一个元素的位置</value>
 81        /// </summary>
 82        public int Last
 83        {
 84            get { return last; }
 85            set { last = value; }
 86        }
 87        
 88        /**//// <summary>
 89        /// <value>顺序表是否已满</value>
 90        /// </summary>
 91        public bool IsFull
 92        {
 93            get
 94            {
 95                return last == maxsize - 1;
 96            }
 97        }
 98
 99        /**//// <summary>
        /// <value>顺序表是否为空</value>
        /// </summary>
        public bool IsEmpty
        {
            get
            {
                return last == -1;
            }
        }

        #endregion

        构造器#region 构造器
        
        /**//// <summary>
        /// 构造一个空顺序表
        /// </summary>
        /// <param name="size">顺序表大小</param>
        public SeqList(int size)
        {
            data = new T[size];
            maxsize = size;
            last = -1;
        }

        #endregion

        IListDS 成员#region IListDS<T> 成员

        /**//// <summary>
        /// 得到长度
        /// </summary>
        /// <returns>顺序表的长度</returns>
        public int GetLength()
        {
            return last + 1;
        }

        /**//// <summary>
        /// 清空顺序表
        /// </summary>
        public void Clear()
        {
            last = -1;
        }

        /**//// <summary>
        /// 末尾附加
        /// </summary>
        /// <param name="item">附加元素</param>
        public void Append(T item)
        {
            if (IsFull)
            {
                Console.WriteLine("Seqlist is full");

                return;
            }
            else
            {
                data[++last] = item;
            }
        }

        /**//// <summary>
        /// 插入操作
        /// </summary>
        /// <param name="item">插入的元素</param>
        /// <param name="position">插入位置</param>
        public void Insert(T item, int position)
        {
            //是否为空
            if (IsFull)
            {
                Console.WriteLine("Seqlist is full");

                return;
            }
            //超出两头边界
            else if (position < 1 || position > last + 2)
            {
                Console.WriteLine("Position is error");

                return;
            }
            //末尾附加
            else if (position == last + 2)
            {
                data[++last] = item;
            }
            else 
            {
                //从最后一个依次往后移1位一直将要插入的那个地方的元素也移走使其空出
                for (int temp = last; end >= position - 1; --temp)
                {
                    data[temp + 1] = data[temp];
                }
                //对将要插入的那个空位附上元素
                data[position - 1] = item;
                //将元素末尾标记加1
                ++last;
            }
        }
        /**//// <summary>
        /// 删除操作
        /// </summary>
        /// <param name="i">删除元素的位置</param>
        /// <returns>被删除的元素</returns>
        public T Delete(int position)
        {
            T temp = default(T);

            //如果为空
            if (IsEmpty)
            {
                Console.WriteLine("The SeqList is empty");

                return temp;
            }
            //超出两头的边界
            if (position < 1 || position > last + 1)
            {
                Console.WriteLine("The position is error!");

                return temp;
            }
            else
            {
                //获取得到的值
                temp = data[position - 1];

                //将position-1后面的挨个循环赋给前一个
                for (int i = position - 1; i <= last; i++)
                {
                    data[i] = data[i + 1];
                }
                --last;

                return temp;
            }

        }
        /**//// <summary>
        /// 得到表中指位置的元素
        /// </summary>
        /// <param name="position">元素位置</param>
        /// <returns>此位置的元素</returns>
        public T GetElement(int position)
        {
            T temp = default(T);

            //如果为空
            if (IsEmpty)
            {
                Console.WriteLine("The SeqList is empty");

                return temp;
            }
            //超出两头的边界
            if (position < 1 || position > last + 1)
            {
                Console.WriteLine("The position is error!");

                return temp;
            }
            else
            {
                return data[position - 1];
            }
        }
        /**//// <summary>
        /// 按元素查找
        /// </summary>
        /// <param name="value">元素</param>
        /// <returns>元素的位置</returns>
        public int Locate(T value)
        {
            int temp = 0;

            //如果为空
            if (IsEmpty)
            {
                Console.WriteLine("The SeqList is empty");

                return -1;
            }
            //循环挨个比较查找
            for ( temp = 0; temp <=last; i++)
            {
                if (value.Equals(data[i]))
                {
                    break;
                }
            }
            //超出边界值
            if (temp > last)
            {
                return -1;
            }

            return temp + 1;
        }

        #endregion
    }
}