用C#实现单向链表

public class Node<T>
{
/// <summary>
/// 数据
/// </summary>
public T NodeData
{
get;
set;
}

/// <summary>
/// 指向下一个节点
/// </summary>
public Node<T> Next
{
get;
set;
}
}

public class SingleList<T>
{
private Node<T> _first;//头节点
private Node<T> _last;//尾节点
private int _length;//链表长度

/// <summary>
/// 头节点
/// </summary>
public T First
{
get { return _first.NodeData; }
}

/// <summary>
/// 尾节点
/// </summary>
public T Last
{
get{ return _last.NodeData; }
}

/// <summary>
/// 链表长度
/// </summary>
public int Length
{
get { return _length; }
}

/// <summary>
/// 链表是否为空
/// </summary>
public bool IsEmpty
{
get { return _first == null; }
}

/// <summary>
/// 清空链表
/// </summary>
public void Clear()
{
_first = null;
}

/// <summary>
/// 追加一个节点
/// </summary>
/// <param name="item"></param>
public void Append(T item)
{
Node<T> newNode = new Node<T>();
newNode.NodeData = item;

if (_first == null)
{
_first = _last = newNode;
}
else
{
_last.Next = newNode;
_last = newNode;
}
_length++;
}

/// <summary>
/// 在指定位置插入节点
/// </summary>
/// <param name="item"></param>
/// <param name="location"></param>
public void Insert(T item, int location)
{
Node<T> tempNodePre;//前一个节点
Node<T> tempNodeNex;//后一个节点
Node<T> newNode = new Node<T>();//待插入新节点

newNode.NodeData = item;

if (this.IsEmpty)//链表为空：不能进行插入操作
{
throw new Exception("链表为空");
}

if (location == 0)//在链表头插入
{
tempNodeNex = _first;
_first = newNode;
newNode.Next = tempNodeNex;
_length++;
return;
}

if (location == _length - 1)//在链表尾插入
{
_last.Next = newNode;
_last = newNode;
_length++;
return;
}

//*********其它位置***********************//
tempNodePre = this.FindNode(location - 1);
if (tempNodePre == null)
{
throw new Exception("位置无效");
}
tempNodeNex = tempNodePre.Next;
tempNodePre.Next = newNode;
newNode.Next = tempNodeNex;
_length++;
}

/// <summary>
/// 删除指定位置的节点
/// </summary>
/// <param name="location"></param>
/// <returns>删除的数据</returns>
public T Delete(int location)
{
T deleteData;
Node<T> tempNodeDel;//待删除节点
Node<T> tempNodePre;//前一个节点
Node<T> tempNodeNex;//后一个节点

if (this.IsEmpty)
{
throw new Exception("链表为空，不能删除节点");
}
if (location == 0)//删除头节点
{
deleteData = _first.NodeData;
_first = _first.Next;
_length--;
return deleteData;
}
if (location == _length - 1)//删除尾节点
{
tempNodeDel = _last;
_last = this.FindNode(location - 1);
_last.Next = null;
_length--;
return tempNodeDel.NodeData;
}
//*********其它位置***********************//
tempNodePre = this.FindNode(location - 1);
if (tempNodePre == null)
{
throw new Exception("无效位置");
}
tempNodeDel = tempNodePre.Next;
tempNodeNex = tempNodeDel.Next;
tempNodePre.Next = tempNodeNex;
_length--;
return tempNodeDel.NodeData;
}

/// <summary>
/// 根据索引查找值
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public T Find(int index)
{
if (this.IsEmpty)
{
throw new Exception("链表为空");
}
Node<T> find = this.FindNode(index);
if (find == null)
{
return default(T);
}
return this.FindNode(index).NodeData;
}

/// <summary>
/// 根据索引查找值
/// </summary>
/// <param name="item"></param>
/// <returns>没有找到时返回-1</returns>
public int Find(T item)
{
if (this.IsEmpty)
{
throw new Exception("链表为空");
}
int index = 0;
int result=-1;
Node<T> temp = _first;
while (index < _length)
{
if (temp.NodeData.Equals(item))
{
result = index;
break;
}
temp = temp.Next;
index++;
}
return result;
}

/// <summary>
/// 翻转链表
/// </summary>
public void Reverses()
{
if (this.IsEmpty)
{
return;
}
Node<T> temp = _first.Next;
Node<T> nextNode;
Node<T> currentNode = _first;
while (temp != null)
{
nextNode = temp.Next;
temp.Next = currentNode;
currentNode = temp;
temp = nextNode;
}
Node<T> tempFirst = _first;
_first = _last;
_last = tempFirst;
}

/// <summary>
/// 根据索引找到节点
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
private Node<T> FindNode(int index)
{
if (index < 0 || index >= _length)
{
return null;
}
int i = 0;
Node<T> tempNode = _first;
while (i < index)
{
tempNode = tempNode.Next;
i++;
}
return tempNode;
}
}