C#数据结构二：顺序表Sequence List

最新推荐文章于 2024-07-11 20:33:13 发布

weixin_30745641

最新推荐文章于 2024-07-11 20:33:13 发布

阅读量260

点赞数

CC 4.0 BY-SA版权

文章标签：数据结构与算法 c#

原文链接：http://www.cnblogs.com/walkingp/archive/2010/04/26/1720839.html

本文详细介绍了数据结构中的线性表概念及其基本操作，并深入探讨了顺序表的实现方式，包括添加、删除及查询等功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

线性表是数据结构中最简单、最基本也是最常用的一种，它是线性结构的抽象，上文提到线性结构的特点是结构中的数据元素之间关系为一对一关系。也就是说数据元素是一个接一个的排序。

线性表定义

线性表Linear List：由n(n>=0)个相同类型的数据元素构成的有限序列。记为L=(a₁,a₂,...,a_i-1,a_i,a_i+1,...,a_n)。可使用下式表示：

L=(D,R)

其中，D是数据元素的有限集合，R是数据元素之间关系的有限集合。

线性表基本操作包括插入操作、删除操作、查找、清空等。

线性表的接口类图如下：

接口代码如下：

代码

/// <summary>
/// 线性表接口
/// </summary>
/// <typeparam name="T"></typeparam>
public interface IListDS < T >
{
bool Insert(T item, int pos); // 插入元素
bool IsEmpty(); // 是否为空
int GetLength(); // 得到容量
void Append(T item); // 添加新元素
void Clear(); // 清空
T Delete( int pos); // 删除元素
T GetElem( int pos); // 根据索引查找
int Locate(T value); // 根据值查找
}

线性表的分类

按线性表的元素结构分，可将线性表分为：

1、顺序表：将线性表中的结点按逻辑顺序依次存放在一组地址的存储单元中；

2、链表

1）单向链表：链表的链接方向是单向，对链表的访问要通过顺序读取从头部开始；

2）双向链表：其每个数据结点中都有两个指针，分别指向直接后继和直接前驱。

3）循环链接：其最后一个结点指向头结点，形成一个环；从循环链表中的任何一个结点出发都能找到任何其他结点。

顺序表

顺序表（Sequence List）是在计算机内在中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。

顺序表定义如下：

/// <summary>
/// 顺序表定义
/// </summary>
/// <typeparam name="T"></typeparam>
class SeqListDef < T >
{
    T[] datas; // 存放元素数组
     int pointer; // 索引

     /// <summary>
     /// 构造器
     /// </summary>
     /// <param name="maxSize"></param>
     public SeqListDef( int maxSize)
    {
        datas = new T[maxSize];
    }

     /// <summary>
     /// 增加
     /// </summary>
     /// <param name="item"></param>
     public void AddItem(T item)
    {
        datas[ ++ pointer] = item;
    }

     /// <summary>
     /// 显示元素
     /// </summary>
     public void DisplayItems()
    {
         for ( int j = 0 , l = datas.Length; j < l; j ++ )
        {
            Console.WriteLine( " datas[{0}] " , j);
        }
    }
}

顺序表实现类图如下：

其中GetElem是根据索引来查询，Locate是根据值来查询。

代码如下：

代码

/// <summary>
/// 顺序表
/// </summary>
/// <typeparam name="T"></typeparam>
public class SeqList < T > :IListDS < T >
{
#region 变量成员
private int maxsize; // 容量
private T[] datas; // 存放元素的数组
private int last; // 末位置
#endregion

#region 属性
/// <summary>
/// 最后一个元素位置
/// </summary>
public int Last
{
get
{
return last;
}
}

/// <summary>
/// 容量
/// </summary>
public int MaxSize
{
get
{
return maxsize;
}
set
{
maxsize = value;
}
}
#endregion

/// <summary>
/// 索引器
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public T this [ int index]
{
get
{
return datas[index];
}
set
{
datas[index] = value;
}
}

/// <summary>
/// 构造器
/// </summary>
/// <param name="size"></param>
public SeqList( int size)
{
datas = new T[size];
maxsize = size;
last = - 1 ;
}

#region 方法成员
/// <summary>
/// 得到顺序表长度
/// </summary>
/// <returns></returns>
public int GetLength()
{
return last + 1 ;
}

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

/// <summary>
/// 判断是否为空
/// </summary>
/// <returns></returns>
public bool IsEmpty()
{
if (last ==- 1 )
return true ;
return false ;
}

/// <summary>
/// 判断顺序表是否已满
/// </summary>
/// <returns></returns>
public bool IsFull()
{
if (last == maxsize - 1 )
return true ;
return false ;
}

/// <summary>
/// 添加新元素
/// </summary>
/// <param name="item"></param>
public void Append(T item)
{
if (IsFull())
{
Console.WriteLine( " The List's already full yet " );
return ;
}

datas[ ++ last] = item;
}

/// <summary>
/// 插入元素
/// </summary>
/// <param name="item"> 元素 </param>
/// <param name="pos"> 位置 </param>
/// <returns> 是否插入成功 </returns>
public bool Insert(T item, int pos)
{
if (IsFull())
{
Console.WriteLine( " The List's already full yet " );
return false ;
}
if (pos < 0 || pos > last + 1 )
{
Console.WriteLine( " The position is error " );
return false ;
}
if (pos == last + 1 )
datas[pos] = item;
else
{
for ( int index = last; index >= pos; -- index)
{
datas[index + 1 ] = datas[index];
}
datas[pos] = item;
}
++ last;
return true ;
}

/// <summary>
/// 删除元素
/// </summary>
/// <param name="pos"></param>
/// <returns></returns>
public T Delete( int pos)
{
T tmp = default (T);
if (IsEmpty())
{
Console.WriteLine( " The List is empty " );
return tmp;
}
if (pos <- 0 || pos > last)
{
Console.WriteLine( " The position is err " );
return tmp;
}
if (pos == last)
tmp = datas[last];
else
{
tmp = datas[pos];
for ( int index = pos; index < last; ++ index)
{
datas[index] = datas[index + 1 ];
}
}
-- last;
return tmp;
}

/// <summary>
/// 根据索引查找某一元素
/// </summary>
/// <param name="pos"> 索引 </param>
/// <returns></returns>
public T GetElem( int pos)
{
if (IsEmpty() || (pos < 0 ) || pos > last)
{
Console.WriteLine( " List is empty or the position is error " );
return default (T);
}
return datas[pos];
}

/// <summary>
/// 根据值查找某一元素
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public int Locate(T value)
{
if (IsEmpty())
{
Console.WriteLine( " List is empty " );
return - 1 ;
}
int index = 0 ;
for (index = 0 ; index <= last; ++ index)
{
if (value.Equals(datas[index]))
break ;
}
if (index > last)
return - 1 ;

return index;
}
#endregion
}

实例化调用：

代码

static void Main( string [] args)
{
SeqList < int > seqList = new SeqList < int > ( 8 );
seqList.Append( 21 );
seqList.Append( 22 );
seqList.Append( 23 );

Console.WriteLine( " Inital the sequence list " );
for ( int i = 0 ;i < seqList.GetLength();i ++ )
{
Console.WriteLine(seqList[i]);
}
Console.WriteLine( " Insert method sample: " );
seqList.Insert( 20 , 0 );
seqList.Insert( 24 , 4 );
for ( int i = 0 ;i < seqList.GetLength();i ++ )
{
Console.WriteLine(seqList[i]);
}
Console.WriteLine( " Delete method sample: " );
seqList.Delete( 0 );
for ( int i = 0 ;i < seqList.GetLength();i ++ )
{
Console.WriteLine(seqList[i]);
}
Console.WriteLine( " The 2st item is:{0} " , seqList.GetElem( 1 ));
Console.WriteLine( " The position of value 23 is:{0} " , seqList.Locate( 23 ));
Console.WriteLine( " Empty the sequence list " );
seqList.Clear();
Console.WriteLine( " The length of the sequence list is {0} " ,seqList.GetLength());
}