public static void swap(ref std_forward_list <T> _this, ref std_forward_list <T> _other)
{
std_forward_list <T> temp = _this;
_this = _other;
_other = temp;
}
/// <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);
}
/// <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);
}
/// <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);
}
