/// <summary>
/// 静态方法，在单链表的尾部插入结点建立单链表，一般使用这个方法，符合逻辑
/// </summary>
/// <param name="items"></param>
/// <returns></returns>
public static std_forward_list <T> CreateListTail(T[] items)
{
std_forward_list_node <T> node = new std_forward_list_node <T>();
std_forward_list <T> list = new std_forward_list <T>();
node = list.Head.Next;
for (int i = 0; i < items.Length; i++)
{
std_forward_list_node <T> p = new std_forward_list_node <T>(items[i]);
if (list.Head.Next == null)
{
list.Head.Next = p;
}
else
{
node.Next = p;
}
node = p;
}
if (node != null)
{
node.Next = null;
}
return(list);
}
public T this[int index] {
get {
return(GetElem(index));
}
set {
std_forward_list_node <T> node = GetElemNode(index);
node.Data = value;
}
}
/// <summary>
/// 求单链表长度
/// </summary>
/// <returns>长度</returns>
public int GetLength()
{
std_forward_list_node <T> p = head.Next;
int length = 0;
while (p != null)
{
length++;
p = p.Next;
}
return(length);
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
std_forward_list_node <T> p = head.Next;
//int length = 0;
while (p != null)
{
yield return(p);
//length++;
p = p.Next;
}
}
/// <summary>
/// 静态方法，在单链表的头部插入结点建立单链表，造成链表中的数据与逻辑顺序相反
/// </summary>
/// <param name="items">数组</param>
/// <returns></returns>
public static std_forward_list <T> CreateListHead(T[] items)
{
std_forward_list <T> list = new std_forward_list <T>();
for (int i = 0; i < items.Length; i++)
{
std_forward_list_node <T> p = new std_forward_list_node <T>(items[i]);
p.Next = list.Head.Next;
list.Head.Next = p;
}
return(list);
}
public IEnumerator <T> GetEnumerator()
{
std_forward_list_node <T> p = head.Next;
//int length = 0;
while (p != null)
{
yield return(p.Data);
//length++;
p = p.Next;
}
}
/// <summary>
/// 倒置操作
/// </summary>
public void ReversLinkList()
{
std_forward_list_node <T> p = Head.Next;
std_forward_list_node <T> q = new std_forward_list_node <T>();
Head.Next = null;
while (p != null)
{
q = p;
p = p.Next;
q.Next = Head.Next;
Head.Next = q;
}
}
public T[] get_allocator()
{
List <T> members = new List <T>();
std_forward_list_node <T> p = head.Next;
int length = 0;
while (p != null)
{
members.Add(p.Data);
length++;
p = p.Next;
}
return(members.ToArray());
}
/// <summary>
/// 使用该方法的前提条件是，两个链表均以按非递减顺序排列
/// </summary>
/// <typeparam name="TItem"></typeparam>
/// <param name="other"></param>
/// <returns></returns>
public std_forward_list <T> merge <TItem>(std_forward_list <T> other) where TItem : T
{
std_forward_list <T> linklist = new std_forward_list <T>();
std_forward_list_node <T> p = Head.Next;
std_forward_list_node <T> q = other.Head.Next;
std_forward_list_node <T> s = new std_forward_list_node <T>();
linklist.Head = Head;
linklist.Head.Next = null;
while (p != null && q != null)
{
if (p.Data.CompareTo(q.Data) < 0)
{
s = p;
p = p.Next;
}
else
{
s = q;
q = q.Next;
}
linklist.Add(s.Data);
}
if (p == null)
{
p = q;
}
while (p != null)
{
s = p;
p = p.Next;
linklist.Add(s.Data);
}
return(linklist);
}
/// <summary>
/// 在单链表的末尾添加新元素
/// </summary>
/// <param name="item">元素</param>
public void Add(T item)
{
std_forward_list_node <T> willToInsert = new std_forward_list_node <T>(item);
std_forward_list_node <T> currentNode = new std_forward_list_node <T>();
if (head.Next == null)
{
head.Next = willToInsert;
return;
}
currentNode = head.Next;
while (currentNode.Next != null)
{
currentNode = currentNode.Next;
}
currentNode.Next = willToInsert;
}
public std_forward_list_node <T> GetElemNode(int i)
{
if (empty() || i < 0 || i > this.GetLength() - 1)
{
throw new ArgumentException("ArgumentException:参数不合法，无法获取元素");
}
std_forward_list_node <T> currentNode = new std_forward_list_node <T>();
currentNode = head.Next;
int j = 0;
while (currentNode.Next != null && j < i)
{
j++;
currentNode = currentNode.Next;
}
return(currentNode);
}
/// <summary>
/// 在单链表的第i个结点的位置前插入一个值为item的结点
/// </summary>
/// <param name="i">位置，从0开始的索引值</param>
/// <param name="item">元素值</param>
public void Insert(int i, T item)
{
if (empty() || i < 0)
{
throw new InvalidOperationException("InvalidOperationException:链表为空或参数小于0，无法执行插入操作");
}
if (i >= this.GetLength())
{
throw new InvalidOperationException("InvalidOperationException:插入位置超出范围，无法执行插入操作");
}
if (i == 0)
{
std_forward_list_node <T> willToInsert = new std_forward_list_node <T>(item);
willToInsert.Next = head.Next;
head.Next = willToInsert;
return;
}
std_forward_list_node <T> currentNode = head.Next;
std_forward_list_node <T> tmp = new std_forward_list_node <T>();
int j = 0;
while (currentNode.Next != null && j < i)
{
tmp = currentNode;
currentNode = currentNode.Next;
j++;
}
if (j == i)
{
std_forward_list_node <T> willToInsert = new std_forward_list_node <T>(item);
willToInsert.Next = currentNode;
tmp.Next = willToInsert;
}
}
/// <summary>
/// 在单链表中查找值为item的结点
/// </summary>
/// <param name="item">需要查找的结点值</param>
/// <returns>元素所在的位置，从0开始的索引值</returns>
public int Locate(T item)
{
if (empty())
{
throw new InvalidOperationException("InvalidOperationException:单链表为空，无法执行定位操作");
}
std_forward_list_node <T> currentNode = head.Next;
int i = 0;
while (!currentNode.Data.Equals(item) && currentNode.Next != null)
{
currentNode = currentNode.Next;
i++;
}
if (currentNode.Data.CompareTo(item) == 0)
{
return(i);
}
else
{
return(-1);
}
}
/// <summary>
/// 删除单链表第i个结点
/// </summary>
/// <param name="i">索引值，从0开始</param>
/// <returns>删除的结点的值</returns>
public T Delete(int i)
{
if (empty() || i < 0)
{
throw new ArgumentException("ArgumentException:参数不合法，无法执行删除操作");
}
std_forward_list_node <T> tmp = new std_forward_list_node <T>();
if (i == 0)
{
tmp = head.Next;
head.Next = tmp.Next;
return(tmp.Data);
}
std_forward_list_node <T> currentNode = head.Next;
int j = 0;
while (currentNode.Next != null && j < i)
{
j++;
tmp = currentNode;
currentNode = currentNode.Next;
}
if (j == i)
{
tmp.Next = currentNode.Next;
return(currentNode.Data);
}
else
{
throw new InvalidOperationException("InvalidOperationException:结点不存在，无法执行删除操作");
}
}
private std_forward_list_node <T> head; //头结点
#region 构造函数
public std_forward_list()
{
head = new std_forward_list_node <T>();
}
public std_forward_list_node(T data, std_forward_list_node <T> next)
{
this.data = data;
this.next = next;
}
public std_forward_list_node(std_forward_list_node <T> next)
{
this.next = next;
}
public std_forward_list_node(T data)
{
this.data = data;
this.next = null;
}
private std_forward_list_node <T> next; //引用域
#region 构造函数
public std_forward_list_node()
{
this.data = default(T);
this.next = null;
}
