链表

编写一个程序，找到两个单链表相交的起始节点。 如下面的两个链表： 在节点 c1 开始相交。 示例 1： 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Reference of the node with value = 8 输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。 示例 2： 输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1 输出：Reference of the node with value = 2 输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。 示例 3： 输入：intersectVal = 0, listA = [2,6,4], listB =

160.相交链表 编写一个程序，找到两个单链表相交的起始节点。 如下面的两个链表： 在节点 c1 开始相交。 示例 1： 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Reference of the node with value = 8 输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。 示例 2： 输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1 输出：Reference of the node with value = 2 输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。 示例 3： 输入：intersectVal = 0, listA = [2,6,4],

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。 输入：1->4->5, 1->3->4, 2->6 输出：1->1->2->3->4->4->5->6 python3： class Solution: def mergeKLists(self, lists: List[ListNode]) -> ListNode: if not lists:return n = len(lists) return self.merge(lists, 0, n - 1) def merge(self, lists, left, right): if left == right: return lists[left] mid = left + (right - left) // 2 l1 = self.merge(lists, left, mid) l2 = self.merge(lists, mid + 1, right) return self.mergeTwoLists(l1, l2) def mergeTwoLists(self, l1, l2): if not l1:return l2 if not l2:return l1 if l1.val < l2.val: l1.next = self.mergeTwoLists(l1.next, l2) return l1

在了解完 什么是数据结构 之后，让我们一起来探索下数据结构中常见的一种— 链表 。 链表 链表是数据结构之一， 其中的数据呈线性排列。在链表中，数据的添加和删除都较为方便，就是访问比较耗费时间。 如上图所示就是链表的概念图，Blue、Yellow、Red 这 3 个字符串作为数据被存储于链表中，也就是 数据域 ，每个数据都有 1 个指针，即 指针域 ，它指向下一个数据的内存地址，其中 Red 是最后 1 个数据，Red 的指针不指向任何位置，也就是为 NULL，指向 NULL 的指针通常被称为空指针。 在链表中，数据一般都是分散存储于内存中的，无须存储在连续空间内。 因为数据都是分散存储的，所以如果想要访问数据，只能从第 1 个数据开始，顺着指针的指向一一往下访问（这便是 顺序访问 ）。比如，想要找到 Red 这一数据，就得从 Blue 开始访问，这之后，还要经过 Yellow，我们才能找到 Red。 如果想要添加数据，只需要改变添加位置前后的指针指向就可以，非常简单。比如，在 Blue 和 Yellow 之间添加 Green。 首先将 Blue 的指针指向的位置变成 Green，然后再把 Green 的指针指向 Yellow，数据的添加就大功告成了。 数据的删除也一样，只要改变指针的指向就可以，比如删除 Yellow。 这时，只需要把 Green 指针指向的位置从 Yellow

编写一个程序，找到两个单链表相交的起始节点。 如下面的两个链表： 在节点 c1 开始相交。 示例 1： 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Reference of the node with value = 8 输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。示例 2： 输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1 输出：Reference of the node with value = 2 输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。 示例 3： 输入：intersectVal = 0, listA = [2,6,4], listB =

反转链表 描述 输入一个链表，反转链表后，输出新链表的表头。 代码 (Java) /* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ public class Solution { public ListNode ReverseList ( ListNode head ) { ListNode pReverseHead = null ; // 记录最后的翻转之后的头部节点 ListNode pCur = head ; // 当前节点 ListNode pPre = null ; // 当前节点的前一个节点 while ( pCur != null ) { ListNode pNext = pCur . next ; //当前节点的下一个节点 if ( pNext == null ) pReverseHead = pCur ; pCur . next = pPre ; pPre = pCur ; pCur = pNext ; } return pReverseHead ; } } 思路 定义三个指针：pPre，pCur，pNext，问题就好解决了。 来源： CSDN 作者： KarmenChan 链接： https://blog.csdn

编写一个程序，找到两个单链表相交的起始节点。 例如，下面的两个链表： A: a1 → a2 ↘ c1 → c2 → c3 ↗ B: b1 → b2 → b3 在节点 c1 开始相交。 注意： 如果两个链表没有交点，返回 null . 在返回结果后，两个链表仍须保持原有的结构。 可假定整个链表结构中没有循环。 程序尽量满足 O( n ) 时间复杂度，且仅用 O( 1 ) 内存。 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * } * } */ public class Solution { public ListNode getIntersectionNode(ListNode headA, ListNode headB) { if (headA == null || headB == null) { return null; } int lenA = len(headA); int lenB = len(headB); if (lenA>lenB) { while (lenA != lenB) { headA = headA.next; lenA-

题目描述 编写一个程序，找到两个单链表相交的起始节点。 例如，下面的两个链表： A: a1 → a2 ↘ c1 → c2 → c3 ↗ B: b1 → b2 → b3 在节点 c1 开始相交。 注意： 如果两个链表没有交点，返回 null . 在返回结果后，两个链表仍须保持原有的结构。 可假定整个链表结构中没有循环。 程序尽量满足 O( n ) 时间复杂度，且仅用 O( 1 ) 内存。 解题思路 首先分别获得两个链表的长度，然后让较长的链表先走两个长度的差值，使得两链表尾部对齐。然后两个链表再同时向后移动，并比较节点是否相等。 代码 1 /** 2 * Definition for singly-linked list. 3 * struct ListNode { 4 * int val; 5 * ListNode *next; 6 * ListNode(int x) : val(x), next(NULL) {} 7 * }; 8 */ 9 class Solution { 10 public: 11 int getLength(ListNode *head){ 12 int len = 0; 13 ListNode *node = head; 14 while(node){ 15 len++; 16 node = node->next; 17 } 18 return len;

链表中倒数第k个结点 描述 输入一个链表，输出该链表中倒数第k个结点。 代码 (Java) /* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ public class Solution { public ListNode FindKthToTail ( ListNode head , int k ) { if ( head == null || k == 0 ) return null ; ListNode pFirst = head , pAfter = head ; // pFirst需要领先pAfter (k-1)个位置 for ( int i = 0 ; i < k - 1 ; i ++ ) { // 需要处理k大于总长度的情况 if ( pFirst . next != null ) { pFirst = pFirst . next ; } else return null ; } while ( pFirst . next != null ) { pFirst = pFirst . next ; pAfter = pAfter . next ; } return pAfter ; } } 思路 本题代码时间复杂度是O(n)

LeetCode--链表3-经典问题 题1 反转链表 第一次代码超出时间限制 原因是，反转之后链表的尾部节点和头结点连上了 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode* reverseList(ListNode* head) { // 如果头节点为空 if(!head) return NULL; // 如果链表中只有一个节点 if(!head->next) return head; // ListNode* cur = head; ListNode* pre = nullptr; while( cur ) { ListNode* tmp = cur->next; cur->next = pre; pre = cur; cur = tmp; } return pre; } }; 题2 合并两个有序链表 通过测试： /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode