c#:线性表，链表，栈，队列

有关线性列表、栈、队列的记录。

来源：30.数据结构(C#语言版).pdf

1.线性表

///<summary>
///线性列表接口
///基本操作：在线性列表的任务位置插入和删除元素
///获取元素的值、读出这个值或者修改这个值
///生成和清除（或者重新初始化）线性表
///</summary>
///<typeparamname="T"></typeparam>
publicinterfaceIListDS<T>
{
intGetLength();//求长度
voidClear();//清空操作
boolIsEmpty();//判断线性表是否为空
voidAppend(Titem);//附加操作
voidInsert(Titem,inti);//插入操作
TDelete(inti);//删除操作
TGetElem(inti);//取表元
intLocate(Tvalue);//按值查找
}

///<summary>
///顺序表SequenceList
///</summary>
///<typeparamname="T"></typeparam>
publicclassSeqList<T>:IListDS<T>
{
privateintmaxsize;//顺序表的容量
privateT[]data;//数组，用于存储顺序表中的数据元素
privateintlast;//指示顺序表最后一个元素的位置，如果顺序表为空则last=-1

///<summary>
///索引器
///索引器的定义
///C#中的类成员可以是任意类型，包括数组和集合。当一个类包含了数组和集合成员时，
///索引器将大大简化对数组或集合成员的存取操作。
///定义索引器的方式与定义属性有些类似，其一般形式如下：
///[修饰符]数据类型this[索引类型index]
///{
///get{//获得属性的代码}
///set{//设置属性的代码}
///}
///</summary>
///<paramname="index"></param>
///<returns></returns>
publicTthis[intindex]
{
get{returndata[index];}
set{data[index]=value;}
}

//顺序表最后一个元素的位置，如果顺序表为空则last=-1
publicintLast
{
get{returnlast;}
}
//容量属性
publicintMaxsize
{
get{returnmaxsize;}
set{maxsize=value;}
}
//构造器
publicSeqList(intsize)
{
data=newT[size];
maxsize=size;
last=-1;
}

#regionIListDS<T>成员

///<summary>
///求顺序表的长度
///</summary>
///<returns></returns>
publicintGetLength()
{
returnlast+1;
}
///<summary>
///清空顺序表
///</summary>
publicvoidClear()
{
last=-1;
}
///<summary>
///判断顺序表是否为空
///</summary>
///<returns></returns>
publicboolIsEmpty()
{
if(last==-1)
{
returntrue;
}
else
{
returnfalse;
}
}
///<summary>
///在顺序表的末尾添加新元素
///</summary>
///<paramname="item"></param>
publicvoidAppend(Titem)
{
if(IsFull())
{
Console.WriteLine("Listisfull");
return;
}
data[++last]=item;
}

///<summary>
///在顺序表的第i个数据元素的位置插入一个数据元素
///注意：位置变量i的初始值为1不是0
///</summary>
///<paramname="item"></param>
///<paramname="i">1<=i<=n+1</param>
publicvoidInsert(Titem,inti)
{
if(IsFull())
{
Console.WriteLine("Listisfull");
return;
}
//判断插入的位置是否正确
//i小于1表示在第一个位置之前插入
//i大于last+2表示在最后一个元素后面的第2个位置插入
//1<=i<=n+1为合法位置
if(i<1||i>last+2)
{
Console.WriteLine("Positioniserror");
return;
}
if(i==last+2)//在最后一个位置插入
{
//data[last+1]=item;
data[i-1]=item;
}
else
{
for(intj=last;j>=i-1;--j)//后移an...ai
{
data[j+1]=data[j];
}
data[i-1]=item;//插入
}
++last;//修改表长，长度加1
}
///<summary>
///删除顺序表的第i个数据元素
///</summary>
///<paramname="i"></param>
///<returns></returns>
publicTDelete(inti)
{
Ttemp=default(T);
if(IsEmpty())
{
Console.WriteLine("Listisempty");
returntemp;
}
//判断删除的位置是否正确
//i小于1表示删除第一个位置之前的元素
//i大于last+1表示删除最后一个元素后面的第1个位置的元素
//取值范围：1<=i<=n
if(i<1||i>last+1)
{
Console.WriteLine("Positioniserror");
returntemp;
}
if(i==last+1)//删除最后一个元素
{
temp=data[last--];returntemp;
}
else
{
temp=data[i-1];
for(intj=i;j<=last;++j)//An..Ai+1前移
{
data[j]=data[j+1];
}
}

--last;
returntemp;
}
///<summary>
///获取顺序表的第i个数据元素
///</summary>
///<paramname="i"></param>
///<returns></returns>
publicTGetElem(inti)
{
if(IsEmpty()||(i<1)||(i>last+1))
{
Console.WriteLine("ListisemptyorPositioniserror");
returndefault(T);
}
returndata[i-1];
}
///<summary>
///在顺序表中查找值为value的数据元素
///</summary>
///<paramname="value"></param>
///<returns></returns>
publicintLocate(Tvalue)
{
if(IsEmpty())
{
Console.WriteLine("Listisempty");
return-1;
}
inti=0;
for(;i<=last;++i)
{
if(value.Equals(data[i]))
{
break;
}
}
if(i>last)//顺序表中部存在与给定值相等的元素
{
return-1;
}
returni;
}

#endregion

///<summary>
///由于顺序表空间的限制，需要判断顺序表是否为满
///</summary>
///<returns></returns>
publicboolIsFull()
{
if(last==maxsize-1)
{
returntrue;
}
else
{
returnfalse;
}
}

///<summary>
///将顺序表L倒置，顺序表有随机存储性质
///算法思路：
///把第一个元素与最后一个元素交换，把第二个元素与倒数第二个元素交换。
///一般地，把第i个元素与第n-i个元素交换，i的取值范围是[0..n/2],n为顺序变的长度
///</summary>
///<paramname="L"></param>
publicvoidReversSeqList(SeqList<int>L)
{
inttemp;
intlen=L.GetLength();
for(inti=0;i<=len/2;++i)
{
temp=L[i];
L[i]=L[len-i];
L[len-i]=temp;
}
}

///<summary>
///将有序顺序表La和Lc合并成有序顺序表Lc
///</summary>
///<paramname="La"></param>
///<paramname="Lb"></param>
///<returns></returns>
publicSeqList<int>Merge(SeqList<int>La,SeqList<int>Lb)
{
SeqList<int>Lc=newSeqList<int>(La.maxsize+Lb.maxsize);

inti=0,j=0;

//2个表中都有数据元素
while(i<=La.GetLength()-1&&j<=Lb.GetLength()-1)
{
if(La[i]<Lb[j])
{
Lc.Append(La[i++]);
}
else
{
Lc.Append(Lb[j++]);
}
}
//a表中还有数据元素
while(i<=La.GetLength()-1)
{
Lc.Append(La[i++]);
}
//b表中还有数据元素
while(j<=Lb.GetLength()-1)
{
Lc.Append(Lb[j++]);
}

returnLc;
}

}

2.单链表

///<summary>
///单链表节点
///</summary>
///<typeparamname="T"></typeparam>
publicclassNode<T>
{
privateTdata;//数据域
privateNode<T>next;//引用域

publicNode(Tval,Node<T>p)
{
data=val;
next=p;
}
publicNode(Tval)
{
data=val;
}
publicNode(Node<T>p)
{
next=p;
}
publicNode()
{
data=default(T);
next=null;
}
publicTData
{
get{returndata;}
set{data=value;}
}
publicNode<T>Next
{
get{returnnext;}
set{next=value;}
}
}

///<summary>
///单链表类
///</summary>
///<typeparamname="T"></typeparam>
publicclassLinkList<T>:IListDS<T>
{
privateNode<T>head;//单链表的头指针

publicNode<T>Head
{
get{returnhead;}
set{head=value;}
}
publicLinkList()
{
head=null;
}

#regionIListDS<T>成员

publicintGetLength()
{
Node<T>p=head;
intlen=0;
while(p!=null)
{
++len;
p=p.Next;
}
returnlen;
}

publicvoidClear()
{
head=null;
}

publicboolIsEmpty()
{
if(head==null)returntrue;
elsereturnfalse;
}

publicvoidAppend(Titem)
{
Node<T>q=newNode<T>(item);//待插入节点
Node<T>p=newNode<T>();

if(head==null)
{
head=q;
return;
}

p=head;
while(p.Next!=null)
{
p=p.Next;
}

p.Next=q;
}

//第i个位置节点处插入一个值为item的新节点
//前插操作
publicvoidInsert(Titem,inti)
{
if(IsEmpty()||i<1)
{
Console.WriteLine("ListisemptyorPositioniserror!");
return;
}
if(i==1)
{
Node<T>q=newNode<T>(item);
q.Next=head;
head=q;
return;
}

//查找到第i个位置
Node<T>p=head;
Node<T>r=newNode<T>();//记录第i个位置前的节点
intj=1;
while(p.Next!=null&&j<i)
{
r=p;
p=p.Next;
++j;
}

if(j==i)
{
Node<T>q=newNode<T>(item);
q.Next=p;
r.Next=q;
}
else
{
Console.WriteLine("Positioniserror!");
}
return;
}

//第i个位置节点处插入一个值为item的新节点
//后插操作
publicvoidInsertPost(Titem,inti)
{
if(IsEmpty()||i<1)
{
Console.WriteLine("ListisemptyorPositioniserror!");
return;
}
if(i==1)
{
Node<T>q=newNode<T>(item);
q.Next=head.Next;
head.Next=q;
return;
}

//查找到第i个位置
Node<T>p=head;
intj=1;
while(p.Next!=null&&j<i)
{
p=p.Next;
++j;
}

if(j==i)
{
Node<T>q=newNode<T>(item);
q.Next=p.Next;
p.Next=q;
}
else
{
Console.WriteLine("Positioniserror!");
}
return;
}

publicTDelete(inti)
{
if(IsEmpty()||i<0)
{
Console.WriteLine("ListisemptyorPositioniserror!");
returndefault(T);
}

Node<T>q=newNode<T>();
if(i==1)
{
q=head;
head=head.Next;
returnq.Data;
}

Node<T>p=head;
intj=1;
while(p.Next!=null&&j<i)
{
q=p;//记录删除节点
p=p.Next;
++j;

}

if(j==i)
{
q.Next=p.Next;
returnp.Data;
}
else
{
Console.WriteLine("The"+i+"thnodeisnotexist!");
returndefault(T);
}

}

publicTGetElem(inti)
{
if(IsEmpty())
{
Console.WriteLine("Listisempty!");
returndefault(T);
}

Node<T>p=newNode<T>();
p=head;
intj=1;
while(p.Next!=null&&j<i)
{
p=p.Next;
++j;
}

if(j==i)
{
returnp.Data;
}
else
{
Console.WriteLine("The"+i+"thnodeisnotexist!");
returndefault(T);
}
}

publicintLocate(Tvalue)
{
if(IsEmpty())
{
Console.WriteLine("Listisempty!");
return-1;
}

Node<T>p=newNode<T>();
p=head;
inti=1;
while(!p.Data.Equals(value)&&p.Next!=null)
{
p=p.Next;
++i;
}
returni;
}

#endregion
}

4.栈

#region栈操作
///<summary>
///栈操作接口
///</summary>
///<typeparamname="T"></typeparam>
publicinterfaceIStack<T>
{
intGetLength();
boolIsEmpty();
voidClear();
voidPush(Titem);//入栈
TPop();//出栈
TGetTop();//取栈顶
}

///<summary>
///顺序栈
///</summary>
///<typeparamname="T"></typeparam>
publicclassSeqStack<T>:IStack<T>
{
privateintmaxsize;
privateT[]data;
privateinttop;

publicTthis[intindex]
{
get{returndata[index];}
set{data[index]=value;}

}
publicintMaxsize
{
get{returnmaxsize;}
set{maxsize=value;}
}
publicintTop
{
get{returntop;}
}
publicSeqStack(intsize)
{
data=newT[size];
maxsize=size;
top=-1;
}

#regionIStack<T>成员
publicintGetLength()
{
returntop+1;
}
publicboolIsEmpty()
{
if(top==-1)returntrue;
elsereturnfalse;
}
publicboolIsFull()
{
if(top==maxsize-1)returntrue;
elsereturnfalse;
}
publicvoidClear()
{
top=-1;
}
publicvoidPush(Titem)
{
if(IsFull())
{
Console.WriteLine("Stackisfull!");
return;
}
data[++top]=item;
}
publicTPop()
{
Ttemp=default(T);
if(IsEmpty())
{
Console.WriteLine("Stackisempty!");
returntemp;
}
temp=data[top];
--top;
returntemp;
}
publicTGetTop()
{
if(IsEmpty())
{
Console.WriteLine("Stackisempty!");
returndefault(T);
}
returndata[top];
}
#endregion
}

///<summary>
///链栈
///</summary>
///<typeparamname="T"></typeparam>
publicclassLinkStack<T>:IStack<T>
{
privateNode<T>top;//栈顶指示器
privateintnum;//栈中节点个数

publicNode<T>Top
{
get{returntop;}
set{top=value;}
}
publicintNum
{
get{returnnum;}
set{num=value;}
}

publicLinkStack()
{
top=null;
num=0;
}

#regionIStack<T>成员

publicintGetLength()
{
returnnum;
}

publicboolIsEmpty()
{
if(top==null&&num==0)returntrue;
elsereturnfalse;
}

publicvoidClear()
{
top=null;
num=0;
}

publicvoidPush(Titem)
{
Node<T>q=newNode<T>(item);
if(top==null)
{
top=q;
}
else
{
q.Next=top;
top=q;
}
++num;
}

publicTPop()
{
Ttemp=default(T);
if(IsEmpty())
{
Console.WriteLine("Stackisempty!");
returntemp;
}
Node<T>p=top;
top=top.Next;
--num;
returnp.Data;
}

publicTGetTop()
{
Ttemp=default(T);
if(IsEmpty())
{
Console.WriteLine("Stackisempty!");
returntemp;
}
returntop.Data;
}

#endregion
}

#endregion

5.队列

///<summary>
///队列操作接口
///</summary>
///<typeparamname="T"></typeparam>
publicinterfaceIQueue<T>
{
intGetLength();
boolIsEmpty();
voidClear();
voidIn(Titem);//入队
TOut();//出队
TGetFront();//取队斗元素

}
///<summary>
///循环顺序队列
///</summary>
///<typeparamname="T"></typeparam>
publicclassCSeqQueue<T>:IQueue<T>
{
privateintmaxsize;//容量
privateT[]data;//数组，存储队列元素
privateintfront;//队头
privateintrear;//队尾

publicintMaxsize
{
get{returnmaxsize;}
set{maxsize=value;}
}
publicintFront
{
get{returnfront;}
set{front=value;}
}
publicintRear
{
get{returnrear;}
set{rear=value;}
}
publicTthis[intindex]
{
get{returndata[index];}
set{data[index]=value;}
}
publicCSeqQueue(intsize)
{
data=newT[size];
maxsize=size;
front=rear=-1;
}

#regionIQueue<T>成员

publicintGetLength()
{
return(rear-front+maxsize)%maxsize;
}

publicboolIsEmpty()
{
if(front==rear)returntrue;
elsereturnfalse;
}
//队满和队空时都有rear=front
//解决方法是少用一个空间
publicboolIsFull()
{
if((rear+1)%maxsize==front)returntrue;
elsereturnfalse;
}
publicvoidClear()
{
front=rear=-1;
}

publicvoidIn(Titem)
{
if(IsFull())
{
Console.WriteLine("Queueisfull!");
return;
}
data[++rear]=item;
}

publicTOut()
{
Ttemp=default(T);
if(IsEmpty())
{
Console.WriteLine("Queueisempty!");
returntemp;
}
temp=data[++front];
returntemp;
}

publicTGetFront()
{
Ttemp=default(T);
if(IsEmpty())
{
Console.WriteLine("Queueisempty!");
returntemp;
}
temp=data[front+1];
returntemp;
}

#endregion
}

///<summary>
///链队列
///</summary>
///<typeparamname="T"></typeparam>
publicclassLinkQueue<T>:IQueue<T>
{
privateNode<T>front;//队头
privateNode<T>rear;//队尾
privateintnum;//队列节点个数

publicintNum
{
get{returnnum;}
set{num=value;}
}
publicNode<T>Front
{
get{returnfront;}
set{front=value;}
}
publicNode<T>Rear
{
get{returnrear;}
set{rear=value;}
}

publicLinkQueue()
{
front=rear=null;
num=0;
}

#regionIQueue<T>成员

publicintGetLength()
{
returnnum;
}

publicboolIsEmpty()
{
if(front==rear&&num==0)returntrue;
elsereturnfalse;
}

publicvoidClear()
{
front=rear=null;
}

publicvoidIn(Titem)
{
Node<T>q=newNode<T>(item);

if(rear==null)
{
rear=q;
}
else
{
rear.Next=q;
rear=q;
}
++num;
}

publicTOut()
{
if(IsEmpty())
{
Console.WriteLine("Queueisempty!");
returndefault(T);
}
Node<T>p=front;//先取出链队列头节点
front=front.Next;//指向链队列头节点的直接后继节点
if(front==null)
{
rear=null;
}
--num;
returnp.Data;
}

publicTGetFront()
{
if(IsEmpty())
{
Console.WriteLine("Queueisempty!");
returndefault(T);
}
returnfront.Data;
}

#endregion
}