单链表的操作

最新推荐文章于 2022-04-12 15:41:49 发布
最新推荐文章于 2022-04-12 15:41:49 发布
阅读量87 收藏
点赞数
原文链接：http://www.cnblogs.com/kexianting/p/8602905.html
版权 
public class ListNode { int val; ListNode next; ListNode(int x) { val = x; } }

1. 在 O(1) 时间删除链表节点

Leetcode 237. Delete Node in a Linked List

题目描述：给定单链表中需要删除的节点（不是尾节点），在 O(1) 时间删除该节点。

分析：本题与《编程之美》上的「从无头单链表中删除节点」类似。主要思想都是「狸猫换太子」，即用下一个节点数据覆盖要删除的节点，然后删除下一个节点。但是如果节点是尾节点时，该方法就行不通了。

代码如下：

// 在 O(1) 时间从无头单链表中删除节点
public void deleteNode(ListNode node) { // 不能为空，不能为尾节点 if (null == node || null == node.next) { return; } node.val = node.next.val; node.next = node.next.next; }

2. 逆转单链表

LeetCode 206. Reverse Linked List

题目描述：输出一个单链表的逆序反转后的链表。

分析：非递归的算法很简单，用三个临时指针 prev、cur、next 在链表上循环一遍即可。递归算法是先逆转下一个节点，再逆转当前节点。

下面是两种算法的代码：

// 逆转单链表，循环方法
public ListNode reverseByLoop(ListNode head) { if (null == head || null == head.next) { return head; } ListNode prev = null; ListNode next = null; // 用 head 作为 cur 指针 while (null != head) { next = head.next; head.next = prev; prev = head; head = next; } return prev; } // 逆转单链表，递归方法 public ListNode reverseByRecursion(ListNode head) { // 第一个条件判断异常，第二个条件是结束递归 if (null == head || null == head.next) { return head; } ListNode newHead = reverseByRecursion(head.next); head.next.next = head; head.next = null; return newHead; }

单链表反转补充:

【 尊重 原创，转载请注明出处】http://blog.csdn.net/guyuealian/article/details/51119499
（一）单链表的结点结构:　
      data域：存储数据元素信息的域称为数据域；　
    next域：存储直接后继位置的域称为指针域，它是存放结点的直接后继的地址（位置）的指针域（链域）。
    data域+ next域：组成数据ai的存储映射，称为结点；
    注意：①链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。 　　
          ②每个结点只有一个链域的链表称为单链表（Single Linked List）。
     所谓的链表就好像火车车厢一样，从火车头开始，每一节车厢之后都连着后一节车厢。
     要实现单链表存储，首先是创建一结点类，其Java代码如下：
[java]  view plain  copy
 
  1. class Node {  
  2.     private int Data;// 数据域  
  3.     private Node Next;// 指针域  
  4.     public Node(int Data) {  
  5.         // super();  
  6.         this.Data = Data;  
  7.     }  
  8.     public int getData() {  
  9.         return Data;  
  10.     }  
  11.     public void setData(int Data) {  
  12.         this.Data = Data;  
  13.     }  
  14.   
  15.     public Node getNext() {  
  16.         return Next;  
  17.     }  
  18.     public void setNext(Node Next) {  
  19.         this.Next = Next;  
  20.     }  
  21. }  
（二）实现反转的方法：
  （1）递归反转法：在反转当前节点之前先反转后续节点。这样从头结点开始，层层深入直到尾结点才开始反转指针域的指向。简单的说就是从尾结点开始，逆向反转各个结点的指针域指向，其过程图如下所示：
   head：是前一结点的指针域（PS：前一结点的指针域指向当前结点）
   head.getNext()：是当前结点的指针域（PS：当前结点的指针域指向下一结点）
   reHead：是反转后新链表的头结点（即原来单链表的尾结点）
Java代码实现：
[java]  view plain  copy
 
  1. package javatest1;  
  2. public class javatest1 {  
  3.     public static void main(String[] args) {  
  4.         Node head = new Node(0);  
  5.         Node node1 = new Node(1);  
  6.         Node node2 = new Node(2);  
  7.         Node node3 = new Node(3);  
  8.         head.setNext(node1);  
  9.         node1.setNext(node2);  
  10.         node2.setNext(node3);  
  11.   
  12.         // 打印反转前的链表  
  13.         Node h = head;  
  14.         while (null != h) {  
  15.             System.out.print(h.getData() + " ");  
  16.             h = h.getNext();  
  17.         }  
  18.         // 调用反转方法  
  19.         head = Reverse1(head);  
  20.   
  21.         System.out.println("\n**************************");  
  22.         // 打印反转后的结果  
  23.         while (null != head) {  
  24.             System.out.print(head.getData() + " ");  
  25.             head = head.getNext();  
  26.         }  
  27.     }  
  28.   
  29.     /** 
  30.      * 递归，在反转当前节点之前先反转后续节点 
  31.      */  
  32.     public static Node Reverse1(Node head) {  
  33.         // head看作是前一结点，head.getNext()是当前结点，reHead是反转后新链表的头结点  
  34.         if (head == null || head.getNext() == null) {  
  35.             return head;// 若为空链或者当前结点在尾结点，则直接还回  
  36.         }  
  37.         Node reHead = Reverse1(head.getNext());// 先反转后续节点head.getNext()  
  38.         head.getNext().setNext(head);// 将当前结点的指针域指向前一结点  
  39.         head.setNext(null);// 前一结点的指针域令为null;  
  40.         return reHead;// 反转后新链表的头结点  
  41.     }  
  42. }  
  43.   
  44.     class Node {  
  45.         private int Data;// 数据域  
  46.         private Node Next;// 指针域  
  47.   
  48.         public Node(int Data) {  
  49.             // super();  
  50.             this.Data = Data;  
  51.         }  
  52.   
  53.         public int getData() {  
  54.             return Data;  
  55.         }  
  56.   
  57.         public void setData(int Data) {  
  58.             this.Data = Data;  
  59.         }  
  60.   
  61.         public Node getNext() {  
  62.             return Next;  
  63.         }  
  64.   
  65.         public void setNext(Node Next) {  
  66.             this.Next = Next;  
  67.         }  
  68.     }  
（2）遍历反转法：递归反转法是从后往前逆序反转指针域的指向，而遍历反转法是从前往后反转各个结点的指针域的指向。
   基本思路是：将当前节点cur的下一个节点 cur.getNext()缓存到temp后，然后更改当前节点指针指向上一结点pre。也就是说在反转当前结点指针指向前，先把当前结点的指针域用tmp临时保存，以便下一次使用，其过程可表示如下：
   pre：上一结点
   cur: 当前结点
   tmp: 临时结点，用于保存当前结点的指针域（即下一结点）
 
Java代码实现：
[java]  view plain  copy
 
  1. package javatest1;  
  2. public class JavaTest1 {  
  3.     public static void main(String[] args) {  
  4.         Node head = new Node(0);  
  5.         Node node1 = new Node(1);  
  6.         Node node2 = new Node(2);  
  7.         Node node3 = new Node(3);  
  8.   
  9.         head.setNext(node1);  
  10.         node1.setNext(node2);  
  11.         node2.setNext(node3);  
  12.   
  13.         // 打印反转前的链表  
  14.         Node h = head;  
  15.         while (null != h) {  
  16.             System.out.print(h.getData() + " ");  
  17.             h = h.getNext();  
  18.         }  
  19.         // 调用反转方法  
  20.         // head = reverse1(head);  
  21.         head = reverse2(head);  
  22.   
  23.         System.out.println("\n**************************");  
  24.         // 打印反转后的结果  
  25.         while (null != head) {  
  26.             System.out.print(head.getData() + " ");  
  27.             head = head.getNext();  
  28.         }  
  29.     }  
  30.   
  31.     /** 
  32.      * 遍历，将当前节点的下一个节点缓存后更改当前节点指针 
  33.      */  
  34.     public static Node reverse2(Node head) {  
  35.         if (head == null)  
  36.             return head;  
  37.         Node pre = head;// 上一结点  
  38.         Node cur = head.getNext();// 当前结点  
  39.         Node tmp;// 临时结点，用于保存当前结点的指针域（即下一结点）  
  40.         while (cur != null) {// 当前结点为null，说明位于尾结点  
  41.             tmp = cur.getNext();  
  42.             cur.setNext(pre);// 反转指针域的指向  
  43.   
  44.             // 指针往下移动  
  45.             pre = cur;  
  46.             cur = tmp;  
  47.         }  
  48.         // 最后将原链表的头节点的指针域置为null，还回新链表的头结点，即原链表的尾结点  
  49.         head.setNext(null);  
  50.           
  51.         return pre;  
  52.     }  
  53. }  
  54.   
  55. class Node {  
  56.     private int Data;// 数据域  
  57.     private Node Next;// 指针域  
  58.   
  59.     public Node(int Data) {  
  60.         // super();  
  61.         this.Data = Data;  
  62.     }  
  63.   
  64.     public int getData() {  
  65.         return Data;  
  66.     }  
  67.   
  68.     public void setData(int Data) {  
  69.         this.Data = Data;  
  70.     }  
  71.   
  72.     public Node getNext() {  
  73.         return Next;  
  74.     }  
  75.   
  76.     public void setNext(Node Next) {  
  77.         this.Next = Next;  
  78.     }  
  79. }  

3. 删除单链表倒数第 n 个节点

LeetCode 19. Remove Nth Node From End of List

题目描述：删除单链表倒数第 n 个节点，1 <= n <= length，尽量在一次遍历中完成。

分析：看到题目时的第一想法是先遍历一次计算出单链表的长度 length，然后在遍历第二次删除第 length - n + 1 个节点，但是这需要遍历两次。正常的删除第 n 个节点只需要遍历一次就可以，如何只遍历一次找到倒数第 n 个节点呢？可以设置两个指针 p1、p2，首先 p1 和 p2 都指向 head，p2 移动到第 n 个节点，然后 p1 和 p2 同时向后移动，当 p2 移动到末尾时，p1 刚好指向倒数第 n 个节点。因为最后要删除倒数第 n 个节点，所以可以找到倒数第 n + 1 个节点，方便删除节点。

代码如下：

// 遍历一次，删除单链表倒数第 n 个节点
public ListNode removeNthFromEnd(ListNode head, int n) { if (null == head) { return head; } ListNode p1 = head; ListNode p2 = head; // 1. p2 移动到第 n + 1 个节点 for (int i = 0; i < n; i ++>) { p2 = p2.next; } // n == 链表长度时，p2 指向第 n + 1 节点为空，倒数第 n 个节点就是头节点 if (null == p2) { p1 = head.next; return p1; } // p1 和 p2 同时向后移动，直到 p2 到达尾节点 while (null != p2.next) { p1 = p1.next; p2 = p2.next; } // 此时 p1 指向倒数第 n + 1 个节点，删除它的下一个节点 p1.next = p1.next.next; return head; }

4. 求单链表的中间节点

题目描述：求单链表的中间节点，如果链表的长度为偶数，返回中间两个节点的任意一个，若为奇数，则返回中间节点。

分析：这道题的思路和第 3 题「删除单链表倒数第 n 个节点」很相似。如果要求只能遍历一遍链表的花，也通过两个指针来完成。两个指针从头节点开始，慢指针每次向后移动一步，快指针每次向后移动两步，直到快指针移动到尾节点时，慢指针移动到中间节点。

// 遍历一次，找出单链表的中间节点
public ListNode findMiddleNode(ListNode head) { if (null == head) { return; } ListNode slow = head; ListNode fast = head; //如果要求在单链表长度为偶数的情况下，返回中间两个节点的第一个，可以用下面的循环条件 //while(null != fast.next && null != fast.next.next) while (null != fast && null != fast.next) { fast = fast.next.next; slow = slow.next; } return slow; }

5. 判断单链表是否存在环

LeetCode 141. Linked List Cycle

题目描述：判断一个单链表是否有环

分析：还是通过快慢指针来解决，两个指针从头节点开始，慢指针每次向后移动一步，快指针每次向后移动两步，如果存在环，那么两个指针一定会在环内相遇。

代码如下：

// 判断单链表是否有环
public boolean hasCycle(ListNode head) { if (null == head) { return false; } ListNode slow = head; ListNode fast = head; while (null != fast.next && null != fast.next.next) { fast = fast.next.next; slow = slow.next; if (fast == slow) { return true; } } return false; }

6. 单链表是否有环扩展：找到环的入口点

LeetCode 142. Linked List Cycle II

题目描述：判断单链表是否有环，如果有，找到环的入口点

分析：由上题可知，按照 p2 每次两步，p1 每次一步的方式走，发现 p2 和 p1 重合，确定了单向链表有环路了。接下来，让 p2 回到链表的头部，重新走，每次步长不是走 2 了，而是走 1，那么当 p1 和 p2 再次相遇的时候，就是在环路的入口点。

假设起点到环入口的距离尾 a，p1 和 p2 第一次相遇的相交点 M 与环入口的距离为 b，环的周长为 L，当 p1 和 p2 第一次相遇时，假设 p1 走了 n 步。其中 p1 和 p2 第一次相遇时，p1 在环内走过的步数为 b，因为当 p1 走到环入口时，p2 已经在环内了，假设此时 p2 走到环入口的步数为 c，那么 p1 再走 c 步 p2 刚好追上来和 p1 相遇，c < L，所以此时 p1 肯定还没走完一圈。那么根据上面的假设，有下面的关系：

p1 走的路径：a + b = n
p2 走的路径：a + b + k * L = 2n，假设此时 p2 比 p1 多走了 k 圈环路，k >= 1

根据上面的两个等式可以得出k * L = n = a + b，那么从相交点 M 开始，p1 再走 a（a = k * L - b） 步，就相当于走了 k 圈，然后回退 b 步，注意环入口到相交点的距离刚好为 b，所以 p1 再走 a 步时到达环入口；而 p2 从头开始走 a 的话也到达了环入口，与 p1 相遇。

而在后面这个步骤中，p1 和 p2 前 a 步走的路径不同，再次相遇时必然在环的入口点。

代码如下：

// 找到环的入口点
public ListNode findLoopPort(ListNode head) { if (null == head) { return null; } ListNode p1 = head; ListNode p2 = head; boolean hasCycle = false; // 1. 判断是否有环 while (null != p2.next && null != p2.next.next) { p1 = p1.next; p2 = p2.next.next; if (p1 == p2) { hasCycle = true; break; } } if (!hasCycle) { return null; } // p2 从头开始走，步长变为 1 p2 = head; while (p1 != p2) { p1 = p1.next; p2 = p2.next; } return p1; }

7. 判断两个无环单链表是否相交

题目描述：给出两个无环单链表

A:       a1 → a2
                 ↘
                    c1 → c2 → c3 → null
                 ↗            
B:  b1 → b2 → b3

判断 A 和 B 是否相交。

分析：

1.最直接的方法是判断 A 链表的每个节点是否在 B 链表中，但是这种方法的时间复杂度为 O(Length(A) * Length(B))。

2.转化为环的问题。把 B 链表接在 A 链表后面，如果得到的链表有环，则说明两个链表相交。可以之前讨论过的快慢指针来判断是否有环，但是这里还有更简单的方法。如果 B 链表和 A 链表相交，把 B 链表接在 A 链表后面时，B 链表的所有节点都在环内，所以此时只需要遍历 B 链表，看是否会回到起点就可以判断是否相交。这个方法需要先遍历一次 A 链表，找到尾节点，然后还要遍历一次 B 链表，判断是否形成环，时间复杂度为 O(Length(A) + Length(B))。

3.除了转化为环的问题，还可以利用“如果两个链表相交于某一节点，那么之后的节点都是共有的”这个特点，如果两个链表相交，那么最后一个节点一定是共有的。所以可以得出另外一种解法，先遍历 A 链表，记住尾节点，然后遍历 B 链表，比较两个链表的尾节点，如果相同则相交，不同则不相交。时间复杂度为 O(Length(A) + Length(B))，空间复杂度为 O(1)，思路比解法 2 更简单。

解法 3 的代码如下：

// 判断两个无环单链表是否相交
public boolean isIntersect(ListNode headA, ListNode headB) { if (null == headA || null == headB) { return false; } if (headA == headB) { return true; } while (null != headA.next) { headA = headA.next; } while (null != headB.next) { headB = headB.next; } return headA == headB; }

8. 两个链表相交扩展：判断两个有环单链表是否相交

题目描述：上面的问题是针对无环链表的，如果是链表有环呢？

分析：如果两个有环单链表相交，那么它们一定共有一个环。因此可以先用之前快慢指针的方式找到两个链表中位于环内的两个节点，如果相交的话，两个节点在一个环内，那么移动其中一个节点，在一次循环内肯定可以与另外一个节点相遇。

代码如下：

// 判断两个有环单链表是否相交
public boolean isisIntersectWithLoop(ListNode headA, ListNode headB) { if (null == headA || null == headB) { return false; } if (headA == headB) { return true; } headA = hasCycle(headA); headB = hasCycle(headB); // 没有环，则退出 if (null == headA || headB) { return false; } ListNode p = headB.next; // p 在环内循环一次，直到与 headA 相遇 while (p != headB) { if (p == headA) { return true; } p = p.next; } return false; } // 判断单链表是否有环，并返回环内的某一节点 public ListNode hasCycle(ListNode head) { if (null == head) { return null; } ListNode slow = head; ListNode fast = head; while (null != fast.next && null != fast.next.next) { fast = fast.next.next; slow = slow.next; if (fast == slow) { return slow; } } return null; }

9. 两个链表相交扩展：求两个无环单链表的第一个相交点

LeetCode 160. Intersection of Two Linked Lists

题目描述：找到两个无环单链表第一个相交点，如果不相交返回空，要求在线性时间复杂度和常量空间复杂度内完成。

分析：

下面所说的对齐：表示指针到链表末尾的距离相同。

  1. 分为先判断是否有环，再求第一个相交点的方式。分别遍历 A 链表和 B 链表，判断它们的最后一个节点是否相交。然后利用对齐的思想，计算两个链表的长度（这个可以放在之前的遍历中做），分别用 p1 和 p2 指向两个链表的头，然后将较长链表的 p1 (假设为 p1)向后移动 LB - LA 个节点。这样 p1 和 p2 对齐了，然后同时向后移动 p1 和 p2，直到 p1 == p2，相遇的点就是第一个节点。

  2. 解法 1 中为了对齐需要计算链表的长度，有没有什么方法可以不用计算链表长度呢？假设 A 链表和 B 链表的长度为 LA 和 LB，假设 LB >= LA，两个指针 p1 和 p2 分别指向 A 链表和 B 链表的头节点。同时向后移动，当 p1 移动 A 链表的末尾时，p2 距离 B 链表的末尾的距离为 LB - LA，此时可以看出我们已经得到了长度差，如何利用这个长度差对齐呢。这时将 p1 移动到 B 链表的头部，两个指针继续移动，当 p2 移动到 B 链表的末尾时，p1 刚好移动了 LB - LA 步。此时再将 p2 移动到 A 链表的头部，这样 p1 和 p2 就对齐了，然后继续移动，直到 p1 == p2。如果两个链表不相交，p1 和 p2 移动会同时移动到末尾都指向空，而相交的话，第一次相等时就是第一个相交点。这种方法的时间复杂度为 O (2 * (Length(B)))，最多要遍历两次长度较长的链表。

�解法 2 的代码如下：

// 求两个无环单链表的第一个相交点
public ListNode getIntersectionNode(ListNode headA, ListNode headB) { if (null == headA || null == headB) { return null; } if (headA == headB) { return headA; } ListNode p1 = headA; ListNode p2 = headB; while (p1 != p2) { // 遍历完所在链表后从另外一个链表再开始 // 当 p1 和 p2 都换到另一个链表时，它们对齐了： // （1）如果链表相交，p1 == p2 时为第一个相交点 // （2）如果链表不相交，p1 和 p2 同时移动到末尾，p1 = p2 = null，然后退出循环 p1 = (null == p1) ? headB : p1.next; p2 = (null == p2) ? headA : p2.next; } return p1; }

10. 总结

回过头来，会发现上面的链表问题主要用到了「狸猫换太子」、「对齐」以及「两个指针」的方式来提高效率。其中利用两个指针来提供效率的方式经常用到，在遇到链表问题时可以多考虑下这种思路。推荐大家记住这几种典型的链表问题，以后很多类似的题目都可以转换到熟悉的问题再解决。

https://www.jianshu.com/p/a2d53142860c?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation


转载于:https://www.cnblogs.com/kexianting/p/8602905.html

weixin_34186931
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单链表的链接
weixin_44585204的博客
02-17 1664
建立长度为n的单链表A和长度为m的单链表B。编程实现将B表链接在A表的尾端，形成一个单链表A。数据类型指定为字符型。 输入 第一行为A表的长度n； 第二行为A表中的数据元素; 第三行为B表的长度m； 第四行为B表中的数据元素。 输出 输出为链接好后的A表中的所有数据元素。 样例输入 4 A B C D 6 1 2 3 4 5 6 样例输出 A B C D 1 2 3 4 5 6 #include&...
单链表操作
03-26
单链表的基本操作，如创建、插入、删除、输出
SWUST#954: 单链表的链接
qq_50887722的博客
03-31 773
954: 单链表的链接 题目描述 建立长度为n的单链表A和长度为m的单链表B。编程实现将B表链接在A表的尾端，形成一个单链表A。数据类型指定为字符型。 输入 第一行为A表的长度n； 第二行为A表中的数据元素; 第三行为B表的长度m； 第四行为B表中的数据元素。 输出 输出为链接好后的A表中的所有数据元素。 样例输入 4 A B C D 6 1 2 3 4 5 6 样例输出 A B C D 1 2 3 4 5 6 #include<iostream> #include<m
求链表的中间节点
03-09 2068
思路 4. 求链表的中间节点 题目描述：求链表的中间节点，如果链表的长度为偶数，返回中间两个节点的任意一个，若为奇数，则返回中间节点。 分析：此题的解决思路和第3题「求链表的倒数第 k 个节点」很相似。可以先求链表的长度，然后计算出中间节点所在链表顺序的位置。但是如果要求只能扫描一遍链表，如何解决呢？最高效的解法和第3题一样，通过两个指针来完成。用两个指针从链表头节点开始，一
大学实验3指导：利用单链表实现A-B
weixin_30698297的博客
12-06 252
实验目的：深入理解单链表的建立及操作 实验内容： 1．建立单链表A与B 2．实现主要的函数，查找、插入、删除等 3．实现操作A-B 步骤1：包含必要的函数库，对结构体LNode中的抽象数据类型ElemType进行具体定义 1 #include <stdio.h> 2 3 #include <stdlib.h> 4 5 typedef i...
单链表操作基本运算_单链表的基本操作_
10-03
这个压缩包文件“单链表操作基本运算”包含了关于如何在编程中实现单链表基本操作的详细内容，特别是插入和删除操作。 单链表的插入操作通常分为头插法和尾插法。头插法是在链表的开头添加新节点，这需要更新头节点...
数据结构--单链表操作--实验报告.doc
07-11
在本实验中，我们关注的是单链表的创建、查找、插入和合并等基本操作。实验的目标是通过Visual C++编程语言来熟悉程序设计，并掌握单链表的操作。 1. **单链表的创建**： 创建单链表通常从一个空链表开始，然后...
C语言实现单链表，单链表操作
最新发布
02-06
单链表操作：1.创建单链表 2.遍历单链表 3.获取单链表的长度 4.判断单链表是否为空 5.获取节点 6.在尾部插入指定元素 7.在指定位置插入指定元素 8.在头部插入指定元素 9.在尾部删除元素 10.删除所有元素 11.删除指定...
单链表操作算法合集
03-11
代码中包含单链表的常用操作，主要实现以下六个算法： 1.单链表的就地反转 2.链表相交或求公共起始节点 3.求链表倒数第n个节点 4.删除单个节点 5.判断链表是否有环 6.将2个递增的链表合并为递减链表 并全部调试通过...
链表中插入数据并将两个链表相互连接起来
06-26
在链表中插入数据并将两个链表连接起来，本代码是在大学阶段我自己手写的，比较适合正在学习数据结构的朋友，简单易懂。
【数据结构_链表_List_0954】单链表的链接
IronCarrot's Blog
03-05 818
建立长度为n的单链表A和长度为m的单链表B。编程实现将B表链接在A表的尾端，形成一个单链表A。数据类型指定为字符型。 第一行为A表的长度n；  第二行为A表中的数据元素;  第三行为B表的长度m；  第四行为B表中的数据元素。 输出为链接好后的A表中的所有数据元素。 ------------------------------------------------------
链表的链接
liuzuyi200的专栏
03-12 1595
主要的算法思想就是：找到a链表的尾部 和b链表的头部链接在一起就可以了！
关于单链表的链接问题
郭昌的博客
09-23 614
单链表的创建中一般都有q-&gt;next=p；q=p；这个关系。这个关系的作用是使单链表链接起来；否则就会运行不出想要的结果。就像是一个一个点（即创建的节点），这个等式的作用就好比一条线将这些点链接起来。...
单链表的链接 swust oj
yyx的博客
04-18 697
单链表的链接 1000(ms) 65535(kb) 2923 / 9780建立长度为n的单链表A和长度为m的单链表B。编程实现将B表链接在A表的尾端，形成一个单链表A。数据类型指定为字符型。输入第一行为A表的长度n； 第二行为A表中的数据元素; 第三行为B表的长度m； 第四行为B表中的数据元素。输出输出为链接好后的A表中的所有数据元素。样例输入4 A B C D 6 1 2 3 4 5 6 ...
SWUST OJ 954: 单链表的链接
无奈清风吹过的博客
01-03 647
题目描述 建立长度为n的单链表A和长度为m的单链表B。编程实现将B表链接在A表的尾端，形成一个单链表A。数据类型指定为字符型。 输入 第一行为A表的长度n； 第二行为A表中的数据元素; 第三行为B表的长度m； 第四行为B表中的数据元素。 输出 输出为链接好后的A表中的所有数据元素。
线性表（二）——单链表（4）——单链表的连接
Henry's Blog
11-11 1071
/* *Copyright (c) 2015 , 烟台大学计算机学院 *All right resvered . *文件名称: 单链表的逆置.cpp *作 者: 郑兆涵 *线性表（二）——单链表 （4） */ 问题：已知L1和L2分别指向两个单链表的头结点，且已知其长度分别为m、n，请设计算法将L2连接到L1的后面。实现这个算法，完成测试，并分析这个算法的复杂度。 编
SWUST OJ#954 单链表的链接
qq_62102968的博客
04-12 1724
题目 题目描述 建立长度为n的单链表A和长度为m的单链表B。编程实现将B表链接在A表的尾端，形成一个单链表A。数据类型指定为字符型。 输入 第一行为A表的长度n； 第二行为A表中的数据元素; 第三行为B表的长度m； 第四行为B表中的数据元素。 输出 输出为链接好后的A表中的所有数据元素。 样例输入 4 A B C D 6 1 2 3 4 5 6 样例输出 A B C D 1 2 3 4 5 6 思路 和之前的方法一样，先遍历让位置p 指向链表LA的最后一个节点.
C语言实现单链表操作详解：初始化、销毁、反转与合并
接着，文章给出了几个基本的单链表操作的函数实现： 1. **初始化单链表**： `Status InitList(struct LNode **L)` 函数用于创建一个空的带头节点的单链表。它动态分配内存并设置头节点的`next`指针为`NULL`。 2. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值