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

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

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

下面是顺序表的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;
}

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