C#实现单链表合并与去重的算法

仅仅做一次记录

1. 两个非降序单链表的去重加合并

代码实现————注意是直接更改原始链表

public void Merge2(LinkList<T> linkList)
        {
            Node<T> p = this.Head.Next;
            Node<T> q = linkList.Head.Next;
            LinkList<T> newlink = new LinkList<T>();
            newlink.head = this.head;
            Node<T> Newtail = newlink.head;
           // Newtail.Next = null;
            Node<T> newnode = new Node<T>();
            while (p != null && q != null)
            {
                while (p.Next != null && Convert.ToDecimal(p.Data) == Convert.ToDecimal(p.Next.Data))
                {
                    p = p.Next;
                }
                while (q.Next != null && Convert.ToDecimal(q.Data) == Convert.ToDecimal(q.Next.Data))
                {
                    q = q.Next;
                }
                if (Convert.ToDecimal(p.Data) <= Convert.ToDecimal(q.Data))
                {
                    newnode = p;
                    if (Convert.ToDecimal(p.Data) == Convert.ToDecimal(q.Data))
                    {
                        q = q.Next;
                    }
                    p = p.Next;
                }
                else
                {
                    newnode = q;
                    q = q.Next;
                }
              // newnode.Next = null;
                Newtail.Next = newnode;
                Newtail = Newtail.Next;
            }
            if (p == null)
            {
                p = q;
            }

            while (p != null)
            {
                while (Convert.ToDecimal(Newtail.Data) == Convert.ToDecimal(p.Data))
                {
                    p = p.Next;
                }
                Newtail.Next = p;
                Newtail = Newtail.Next;
                p = p.Next;
            }

        }
			//主方法调用
 			LinkList<string> linkList1 = new LinkList<string>();
            linkList1.Input();
            LinkList<string> linkList2 = new LinkList<string>();
            linkList2.Input();
            Console.WriteLine("原始链表1：");
            linkList1.Display();
            Console.WriteLine("原始链表2：");
            linkList2.Display();
            Console.WriteLine("两个非降序链表合并去重");
            linkList1.Merge2(linkList2);
            Console.WriteLine("合并去重后的链表");
            linkList1.Display();
            Console.WriteLine("原始链表1：");
            linkList1.Display();
            Console.WriteLine("原始链表2：");
            linkList2.Display();
            Console.Read();

测试如图

2. 非降序链表合并排序输出（递归算法：）
   注意————两个原始链表都会被更改为新链表

	 /// <summary>
     /// 非降序链表合并排序输出（递归算法：）两个原始链表都会被更改
     /// </summary>
     /// <param name="l1">链表1的头节点</param>
     /// <param name="l2">链表2的头节点</param>
     /// <returns></returns>
     public Node<T> Merge(Node<T> list1, Node<T> list2)
     {
         if (list1 == null)
         {
             return list2;
         }
         if (list2 == null)
         {
             return list1;
         }
         if (Convert.ToDecimal(list1.Data) <= Convert.ToDecimal(list2.Data))
         {
             list1.Next = Merge(list1.Next, list2);
             return list1;
         }
         else
         {
             list2.Next = Merge(list1, list2.Next);
             return list2;
         }

     }
	//方法调用
  	      LinkList<string> h = new LinkList<string>();
          Node<string> a = linkList1.Merge(linkList1.Head, linkList2.Head);
          h.Head = a.Next;
          Console.WriteLine("非降序链表合并排序输出（递归算法：）");
          h.Display();
          Console.WriteLine("原始链表1：");
          linkList1.Display();
          Console.WriteLine("原始链表2：");
          linkList2.Display();
          Console.Read();

测试如图

3. 两个链表首尾合并 不返回新联表
   注意————此方法直接在链表后面追加新链表

	   /// <summary>
      /// 两个非降序链表合并 有重复项 直接更改链表1
      /// </summary>
      /// <param name="linkList">需要合并的链表</param>
      public void Merge1(LinkList<T> linkList)
      {
          if (linkList.head == null)
          {
              return;
          }
          Node<T> A = this.head.Next;
          Node<T> B = linkList.head.Next;
          while (A.Next != null)
          {
              A = A.Next;
          }
          A.Next = B;
      }

	//方法调用
	        Console.WriteLine("两个链表首尾合并，会改变原始链表");
            linkList1.Merge1(linkList2);
            Console.WriteLine("合并后的链表：");
            linkList1.Display();
            Console.WriteLine("原始链表1：");
            linkList1.Display();
            Console.WriteLine("原始链表2：");
            linkList2.Display();
            Console,Read();

测试如图

4. 两个链表首尾合并 返回新链表
   注意————此方法不会改变原始链表
   此方法不适合封装在链表类内部

		/// <summary>
       /// 不更改链表 两个链表首尾合并返回新链表
       /// </summary>
       /// <param name="La"></param>
       /// <param name="Lb"></param>
       /// <returns></returns>
       public static LinkList<string> Merge123(LinkList<string> La, LinkList<string> Lb)
       {
           LinkList<string> ret = new LinkList<string>();
           Node<string> p = La.Head.Next;
           while (p != null)
           {
               ret.Append(p.Data);
               p = p.Next;
           }

           p = ret.Head;
           while (p.Next != null)
           {
               p = p.Next;
           }
           p.Next = Lb.Head.Next;
           return ret;
       }

	//方法调用
         Console.WriteLine("两个链表首尾合并，不改变原始链表");
         LinkList<string> test1 = Merge123(linkList1, linkList2);
         Console.WriteLine("合并后的新链表：");
         test1.Display();
         Console.WriteLine("原始链表1：");
         linkList1.Display();
         Console.WriteLine("原始链表2：");
         linkList2.Display();
         Console.Read();

测试如图

学而时习之 不亦说乎！
注意算法题 画图会更好理解一点 有大佬会两个非降序单链表的去重加合并 比第一个代码更好理解的请留言
递归算法 来源于LeetCode的一道题目 有兴趣的去了解下
代码文件已上传GitHub