艾伟_转载：C#版数据结构之--线性表的链式存储(单链表)

Code

           /// <summary>
/// 将整形顺序表A中大于零的元素放入顺序表B中,把小于零的数据元素放入顺序表C中
/// 算法思想:遍历单链表la,依次读取数据元素与0比较,将小于0的数据元素放入lc,将大于0的放入lb
/// </summary>
/// <param name="la"></param>
        static void PurgeToTwo(SepLinkedList<int> la,SepLinkedList<int> lb,SepLinkedList<int> lc)
        {
            Node<int> p = la.Head;
while (p != null)
            {
if (p.Data > 0)
                    lb.Append(p.Data);
else
                    lc.Append(p.Data);
                p = p.Next;
            }
        }
/// <summary>
/// 取单链表中最小值
/// 算法思想:去取最大值相反
/// </summary>
/// <param name="la"></param>
/// <returns></returns>
        static int GetMin(SepLinkedList<int> la)
        {
            Node<int> p = la.Head;
            Node<int> temp = p;
while (p.Next != null)
            { 
                p = p.Next;
if (temp.Data > p.Data)
                { 
                    temp = p;
                }
            }
return temp.Data;
        }
/// <summary>
/// 取单链表中最大值
/// 算法思想:取链表中的第一个数据元素,然后让这个元素与剩下的元素比较,将两者较小者存入结果中
/// </summary>
/// <param name="la"></param>
/// <returns></returns>
        static int GetMax(SepLinkedList<int> la)
        {
            Node<int> p = la.Head;
            Node<int> temp = p;
while (p.Next != null)
            {
                p = p.Next;
if (temp.Data < p.Data)
                {
                    temp = p;
                }
            }
return temp.Data;
        }
设一顺序表(单链表)中的元素值递增有序,将元素x插入到表中适当的位置,
//并保持顺序表(单链表)的有序性
//分析时间复杂度
        static void Insert(SepLinkedList<int> la, int x)
        {
            Node<int> p = la.Head;
            Node<int> q = new Node<int>();
            Node<int> temp = new Node<int>(x);
if (x < p.Data) //小于第一个元素
            {
                temp.Next = la.Head;
                la.Head = temp;
            }
while (p.Next != null) 
            {
                q = p;
                p = p.Next;
if (q.Data <= x && x <= p.Data)
                {

                    temp.Next = p;
                    q.Next = temp;
return;
                }
            }
if (p != null)
            {
                p.Next = temp;
            }

        }
/// <summary>
/// 提取单链表中不重复的数据元素
/// </summary>
/// <param name="l"></param>
/// <returns></returns>
        static SepLinkedList<int> Purge(SepLinkedList<int> l)
        {
            SepLinkedList<int> result = new SepLinkedList<int>();
            Node<int> p = l.Head;
            Node<int> q = new Node<int>();
            Node<int> s = new Node<int>();

//将第一个元素加入结果链表
            s = p;
            p = p.Next;
            s.Next = null;
            result.Head = s;

while (p != null)
            {
                s = p;
                p = p.Next;
                q = result.Head;

while (q != null && q.Data != s.Data)
                {
                    q = q.Next;
                }
if (q == null)
                {
                    s.Next = result.Head;
                    result.Head = s;
                }
            }
return result;

        }
/// <summary>
/// 将两个存储整型数据元素升序排列的单链表合并,并保持升序
/// 算法思想:将la中的每个元素与lb的元素依次比较,并将每次比较中的小者加入结果链表中,最后将剩余的数据元素加入结果链表中
/// </summary>
/// <param name="la"></param>
/// <param name="lb"></param>
/// <returns></returns>
        static SepLinkedList<int> Merge(SepLinkedList<int> la, SepLinkedList<int> lb)
        {
            Node<int> p = la.Head;
            Node<int> q = lb.Head;
int temp = 0;
            SepLinkedList<int> result = new SepLinkedList<int>();
while (p != null && q != null)
            {
if (p.Data < q.Data)
                {
                    temp = p.Data;
                    p = p.Next;
                }
else
                {
                    temp = q.Data;
                    q = q.Next;
                }

            }
            result.Append(temp);
if (p == null)
            {
                p = q;
            }
while (p != null)
            {
                temp = p.Data;
                result.Append(temp);
                p = p.Next;
            }
return result;

        }