golang力扣leetcode 160.相交链表

简介: golang力扣leetcode 160.相交链表

160.相交链表

160.相交链表

题解

思路1:

1.用map存A的所有节点,赋值为true
2.遍历B的节点,如果map[cnt]=true说明就是交点

思路2:

1.统计A的长和B的长,谁长谁先走几步,走到长度一致位置
2.A和B一起走,遇到相同的节点返回即可
3.如果不相交,返回nil

思路3:

1.设链表A的不相交长为m,B不相交从部分为n,相交长为c,即len(A)=m+c,len(B)=n+c
2.循环,A和B一起走,如果A走到nil了,则A赋值为B的头,如果B走到nil了,则B赋值为A的nil
3.则A走了m+c+n,B走了n+c+m
4.m+c+n即走完了一遍A,并且走完了B的不相交部分,刚好停在了相交节点
5.而如果不相交,就是nil了

代码

func getIntersectionNode(headA, headB *ListNode) *ListNode {
  mp := make(map[*ListNode]bool)
  cur := headA
  for cur != nil {
    mp[cur] = true
    cur = cur.Next
  }
  for headB != nil {
    if mp[headB] {
      return headB
    }
    headB = headB.Next
  }
  return nil
}
func getIntersectionNode(headA, headB *ListNode) *ListNode {
  lenA := getLength(headA)
  lenB := getLength(headB)
  if lenA > lenB {
    cnt := lenA - lenB
    for i := 0; i < cnt; i++ {
      headA = headA.Next
    }
  } else {
    cnt := lenB - lenA
    for i := 0; i < cnt; i++ {
      headB = headB.Next
    }
  }
  for headA != nil && headB != nil {
    if headA == headB {
      return headB
    }
    headA = headA.Next
    headB = headB.Next
  }
  return nil
}
func getLength(root *ListNode) int {
  ans := 0
  for root != nil {
    ans++
    root = root.Next
  }
  return ans
}
func getIntersectionNode(headA, headB *ListNode) *ListNode {
  curA, curB := headA, headB
  for curA != curB {
    if curA != nil {
      curA = curA.Next
    } else {
      curA = headB
    }
    if curB != nil {
      curB = curB.Next
    } else {
      curB = headA
    }
  }
  return curA
}
目录
相关文章
|
10月前
|
Go 开发者 索引
【LeetCode 热题100】路径与祖先:二叉树中的深度追踪技巧(力扣33 / 81/ 153/154)(Go语言版)
本文深入探讨了LeetCode中四道关于「搜索旋转排序数组」的经典题目,涵盖了无重复和有重复元素的情况。通过二分查找的变形应用,文章详细解析了每道题的解题思路和Go语言实现代码。关键点包括判断有序区间、处理重复元素以及如何缩小搜索范围。文章还总结了各题的异同,并推荐了类似题目,帮助读者全面掌握二分查找在旋转数组中的应用。无论是初学者还是有经验的开发者,都能从中获得实用的解题技巧和代码实现方法。
390 14
|
9月前
|
Go
【LeetCode 热题100】DP 实战进阶:最长递增子序列、乘积最大子数组、分割等和子集(力扣300 / 152/ 416 )(Go语言版)
本文深入解析三道经典的动态规划问题:**最长递增子序列(LIS)**、**乘积最大子数组** 和 **分割等和子集**。 - **300. LIS** 通过 `dp[i]` 表示以第 `i` 个元素结尾的最长递增子序列长度,支持 O(n²) 动态规划与 O(n log n) 的二分优化。 - **152. 乘积最大子数组** 利用正负数特性,同时维护最大值与最小值的状态转移方程。 - **416. 分割等和子集** 转化为 0-1 背包问题,通过布尔型 DP 实现子集和判断。 总结对比了三题的状态定义与解法技巧,并延伸至相关变种问题,助你掌握动态规划的核心思想与灵活应用!
364 1
|
9月前
|
分布式计算 算法 Go
【LeetCode 热题100】BFS/DFS 实战:岛屿数量 & 腐烂的橘子(力扣200 / 994 )(Go语言版)
本文讲解了两道经典的图论问题:**岛屿数量(LeetCode 200)** 和 **腐烂的橘子(LeetCode 994)**,分别通过 DFS/BFS 实现。在“岛屿数量”中,利用深度或广度优先搜索遍历二维网格,标记连通陆地并计数;“腐烂的橘子”则采用多源 BFS,模拟腐烂传播过程,计算最短时间。两者均需掌握访问标记技巧,是学习网格搜索算法的绝佳实践。
406 1
|
9月前
|
Go
【LeetCode 热题100】BFS/DFS 实战:岛屿数量 & 腐烂的橘子(力扣200 / 994 )(Go语言版)
本篇博客详细解析了三道经典的动态规划问题:198. 打家劫舍(线性状态转移)、279. 完全平方数与322. 零钱兑换(完全背包问题)。通过 Go 语言实现,帮助读者掌握动态规划的核心思想及其实战技巧。从状态定义到转移方程,逐步剖析每道题的解法,并总结其异同点,助力解决更复杂的 DP 问题。适合初学者深入理解动态规划的应用场景和优化方法。
291 0
|
9月前
|
算法 Go 索引
【LeetCode 热题100】回溯:括号生成 & 组合总和(力扣22 / 39 )(Go语言版)
本文深入解析了LeetCode上的两道经典回溯算法题:**22. 括号生成**与**39. 组合总和**。括号生成通过维护左右括号数量,确保路径合法并构造有效组合;组合总和则允许元素重复选择,利用剪枝优化搜索空间以找到所有满足目标和的组合。两者均需明确路径、选择列表及结束条件,同时合理运用剪枝策略提升效率。文章附有Go语言实现代码,助你掌握回溯算法的核心思想。
373 0
【移除链表元素】LeetCode第203题讲解
【移除链表元素】LeetCode第203题讲解
165 0
|
存储 SQL 算法
LeetCode力扣第114题:多种算法实现 将二叉树展开为链表
LeetCode力扣第114题:多种算法实现 将二叉树展开为链表
|
存储 SQL 算法
LeetCode 题目 86:分隔链表
LeetCode 题目 86:分隔链表
|
存储 算法 Java
【经典算法】Leetcode 141. 环形链表(Java/C/Python3实现含注释说明,Easy)
【经典算法】Leetcode 141. 环形链表(Java/C/Python3实现含注释说明,Easy)
204 2
<数据结构>五道LeetCode链表题分析.环形链表,反转链表,合并链表,找中间节点.
<数据结构>五道LeetCode链表题分析.环形链表,反转链表,合并链表,找中间节点
251 1