c#数据结构学习——单链表

public interface IListDS<T>
{
int GetLength();  //求长度
void Clear();     //清空操作
bool IsEmpty();   //判断线性表是否为空
void Append(T item); //附加操作
void Insert(T item,int i); //插入操作
T Delete(int i);  //删除操作
T GetElem(int i); //取表元
int Locate(T value); //按值查找
void Reverse();
}

//结点
public class Node<T>
{
private T data;  //数据域
private Node<T> next;  //引用域
//构造器
public Node(T val,Node<T> p)
{
data=val;
next=p;
}
//构造器
public Node(T val)
{
data=val;
next=null;
}
//构造器
public Node(Node<T> p)
{
next=p;
}
//构造器
public Node()
{
data=default(T);
next=null;
}
//获取或设置数据域属性
public T Data
{
get
{
return data;
}
set
{
data=value;
}
}
//获取或设置引用域属性
public Node<T> Next
{
get
{
return next;
}
set
{
next=value;
}
}
}
//单链表
public class LinkList<T>:IListDS<T>
{
//构造器
public LinkList()
{
head=null;
}
private Node<T> head;  //单链表的头引用
//头引用属性
public Node<T> Head
{
get
{
return head;
}
set
{
head=value;
}
}
//求单链表的长度
public int GetLength()
{
Node<T> p=head;
int len=0;
while(p!=null)
{
++len;
p=p.Next;
}
return len;
}
//清空单链表
public void Clear()
{
head=null;
}
//判断单链表是否为空
public bool IsEmpty()
{
if(head==null)
{
return true;
}
else
{
return false;
}
}

//在单链表的末尾添加新元素
public void Append(T item)
{
Node<T> q=new Node<T>(item);
Node<T> p=new Node<T>();

if(head==null)
{
head=q;
return;
}
p=head;
//找到最后一个结点的位置
while(p!=null)
{
p=p.Next;
}
p.Next=q;
}
//在单链表的第i个结点的位置 前 出入一个值为item的结点
public void Insert(T item,int i)
{
Node<T> q=new Node<T>(item);
Node<T> p=new Node<T>();
if(IsEmpty()||i<1)
{
Console.WriteLine("LinkList is empty or Position is error");
return;
}
//插入在链表的头节点处
if(i==1)
{
q.Next=head;
head=q;
return;
}
p=head;
int j=1;
Node<T> r=new Node<T>();
while(p.Next!=null&&j<i)
{
r=p;
p=p.Next;
++j;
}
if(j==i)
{
q.Next=p;
r.Next=q;
}
}
//在单链表的第i个结点的位置 后 插入一个值为item的结点
public void InsertPost(T item,int i)
{
if(IsEmpty()||i<1)
{
Console.WriteLine("LinkList is empty or Position is error");
return;
}
Node<T> q=new Node<T>(item);
Node<T> p=new Node<T>();
int j=1;
p=head;
while(p!=null&&j<i)
{
p=p.Next;
j++;
}
if(j==i)
{
q.Next=p.Next;
p.Next=q;
}
}

//删除单链表的第i个结点
public T Delete(int i)
{
if(IsEmpty()||i<1)
{
Console.WriteLine("Link is empty or Position is error.");
return default(T);
}
Node<T> q=new Node<T>();
if(i==1)
{
q=head;
head=head.Next;
return q.Data;
}
Node<T> p=new Node<T>();
p=head;
int j=1;
while(p.Next!=null&&j<i)
{
q=p;
p=p.Next;
j++;
}
if(j==i)
{
q.Next=p.Next;
return p.Data;
}
else
{
Console.WriteLine("The ith node is not exist!");
return default(T);
}
}
//获得单链表的第i个数据元素
public T GetElem(int i)
{
if(IsEmpty())
{
Console.WriteLine("List is empty!");
return default(T);
}
Node<T> p=new Node<T>();
p=head;
int j=1;
while(p.Next!=null&&j<i)
{
p=p.Next;
j++;
}
if(j==i)
{
return p.Data;
}
else
{
Console.WriteLine("The ith mode is not exist!");
return default(T);
}
}
//在单链表中查找值为value的结点
public int Locate(T value)
{
if(IsEmpty())
{
Console.WriteLine("List is empty!");
}
Node<T> p=new Node<T>();
p=head;
int j=1;
while(!p.Data.Equals(value)&&p.Next!=null)
{
p=p.Next;
j++;
}
return j;
}
//单链表倒置
public void Reverse()
{
Node<T> p=head.Next;
Node<T> q=new Node<T>();
head.Next=null;

while(p!=null)
{
q=p;
p=p.Next;
q.Next=head.Next;//考虑插入操作
head.Next=q;
}
}
}

//在单链表的头部插入结点  建立  单链表
LinkList<int> CreateListHead()
{
//创建一个链表
LinkList<int> L=new LinkList<int>();
int d;
//输入一个数据
d=Int32.Parse(Console.ReadLine());

//用-1作为输入数据的结束标志
while(d!=-1)
{
Node<int> p=new Node<int>(d);
p.Next=L.Head;
L.Head=p;
d=Int32.Parse(Console.ReadLine());
}
return L;
}
//在单链表的尾部插入结点  建立  单链表
LinkList<int> CreateListTail()
{
LinkList<int> L=new LinkList<int>();
Node<int> p=new Node<int>();
p=L.Head;
int d=Int32.Parse(Console.ReadLine());
while(d!=-1)
{
Node<int> q=new Node<int>(d);
if(p==null)
{
L.Head=q;
}
else
{
p.Next=q;
}
p=q;
d=Int32.Parse(Console.ReadLine());
}
if(p!=null)
{
p.Next=null;
}
return L;
}
//将两表合并成一表
public LinkList<int> Merge(LinkList<int> Ha,LinkList<int>Hb)
{
LinkList<int> Lc=new LinkList<int>();
Node<int> p=Ha.Next;
Node<int> q=Hb.Next;
Node<int> s=Node<int>();
Lc=Ha;
Lc.Next=null;
while(p!=null&&q!=null)
{
if(p.Data<q.Data)
{
s=p;
p=p.Next;
}
else
{
s=q;
q=q.Next;
}
Lc.Append(s);
}

if(p==null)
{
p=q;
}
while(p!=null)
{
s=p;
p=p.Next;
Lc.Append(s);
}
return Lc;

}

//把结点插入到链表Hc头部合并Ha和Hb的算法
public LinkList<int> Merge(LinkList<int> Ha,LinkList<int> Hb)
{
LinkList<int> Hc=new LinkList<int>();
Node<int> p=Ha.Next;
Node<int> q=Hb.Next;
Node<int> s=Node<int>();
Hc=Ha;
Hc.Next=null;
while(p!=null&&q!=null)
{
if(p.Data<q.Data)
{
s=p;
p=p.Next;
}
else
{
s=q;
q=q.Next;
}
s.Next=Hc.Next;
Hc.Next=s;
}
if(p==null)
{
p=q;
}
while(p!=null)
{
s=p;
p=p.Next;
s.Next=Hc.Next;
Hc.Next=s;
}
return Hc;
}
//已知一个存储整数的单链表Ha,试构造单链表Hb，要求单链表Hb中只包含
//单链表Ha中所有值不相同的结点
public LinkList<int> Purge(LinkList<int> Ha)
{
LinkList<int> Hb=new LinkList<int>();
Node<int> p=Ha.Next;
Node<int> q=new Node<int>();
Node<int> s=new Node<int>();
//将Ha的第一个元素作为Hb的第一个元素
s=p;
p=p.Next;
s.Next=null;
Hb.Next=s;
while(p!=null)
{
s=p;
p=p.Next;
q=Hb.Next;
while(q!=null&&q.Data!=s.Data)
{
q=q.Next;
}
if(q==null)
{
//插入元素结点
s.Next=Hb.Next;
Hb.Next=s;
}
}
}