【LeetCode】25. K 个一组翻转链表

原创 于 2025-08-23 14:22:20 发布 · 850 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#leetcode #链表 #算法 #职场和发展 #深度优先 #数据结构

文章目录

25. K 个一组翻转链表

题目描述

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 1：

在这里插入图片描述

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]

示例 2：

在这里插入图片描述

输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]

提示：

  • 链表中的节点数目为 n
  • 1 <= k <= n <= 5000
  • 0 <= Node.val <= 1000

进阶：你可以设计一个只用 O(1) 额外内存空间的算法解决此问题吗？

解题思路

1. 算法分析

1.1 问题本质

这道题是分组翻转链表的经典问题，核心要求是：

  • 将链表按K个节点为一组进行分组
  • 每组内部进行完全翻转
  • 组与组之间保持原有顺序
  • 最后不足K个的节点保持原顺序
1.2 关键挑战
  1. 分组边界确定：如何准确识别每组K个节点的边界
  2. 组内翻转：如何高效翻转指定区间内的节点
  3. 组间连接：翻转后如何正确连接相邻组
  4. 边界处理：最后不足K个节点的处理策略
  5. 空间优化：如何在O(1)额外空间内完成操作
1.3 算法分类

根据实现方式，可以分为三大类：

  • 迭代法：使用循环逐个处理每组节点
  • 递归法：使用递归处理子问题
  • 优化迭代法：在迭代基础上减少不必要的遍历

2. 核心算法详解

2.1 迭代法（推荐解法）
2.1.1 算法思想

迭代法的核心思想是分组处理 + 区间翻转：

  1. 使用虚拟头节点简化头节点处理
  2. 循环检查每组是否有K个节点
  3. 对每组进行区间翻转
  4. 重新连接翻转后的节点
  5. 移动到下一组继续处理
2.1.2 详细流程图
flowchart TD
    A[开始：创建虚拟头dummy] --> B[初始化prev = dummy]
    B --> C[进入主循环]
    C --> D[检查剩余节点数量]
    D --> E{是否还有k个节点?}
    E -->|否| F[退出循环，返回dummy.Next]
    E -->|是| G[确定当前组边界]
    G --> H[翻转当前组[start, end]]
    H --> I[重新连接节点]
    I --> J[移动prev到下一组前驱]
    J --> C
    
    subgraph "翻转过程"
        K[保存start和next引用] --> L[调用reverseList翻转]
        L --> M[prev.Next = 翻转后的头]
        M --> N[翻转后的尾.Next = next]
    end
    
    style A fill:#e1f5fe
    style F fill:#c8e6c9
    style H fill:#fff3e0
    style J fill:#f3e5f5
2.1.3 分组边界确定策略
graph LR
    subgraph "分组边界确定"
        A[prev] --> B[start]
        B --> C[node2]
        C --> D[node3]
        D --> E[end]
        E --> F[next]
    end
    
    subgraph "边界检查逻辑"
        G[从prev开始] --> H[向后遍历k步]
        H --> I[到达end节点]
        I --> J{end.Next是否为nil?}
        J -->|是且不足k个| K[不翻转，退出]
        J -->|否或刚好k个| L[翻转当前组]
    end

边界确定算法：

// 检查是否还有k个节点
end := prev
for i := 0; i < k && end.Next != nil; i++ {
    end = end.Next
}
if end.Next == nil && prev.Next != end {
    // 剩余节点不足k个，不翻转
    break
}
2.1.4 区间翻转详解
否
是
翻转过程示例
第一步: nil<-1 2->3->4
初始: 1->2->3->4
第二步: nil<-1<-2 3->4
第三步: nil<-1<-2<-3 4
完成: nil<-1<-2<-3<-4
reverseList开始
初始化prev = nil, curr = start
curr != end.Next?
返回end, start
保存next = curr.Next
curr.Next = prev
prev = curr
curr = next

翻转步骤详解：

  1. 保存引用：next = curr.Next
  2. 翻转指针：curr.Next = prev
  3. 移动指针：prev = curr, curr = next
  4. 重复直到：curr == end.Next
2.1.5 节点重新连接策略
翻转后状态
翻转前状态
prev.Next = reversedStart
reversedEnd.Next = next
reversedStart
prev
reversedEnd
next
start
prev
node2
node3
end
next

连接操作：

// 翻转[start, end]区间
reversedStart, reversedEnd := reverseList(start, end)

// 重新连接
prev.Next = reversedStart        // 前驱指向翻转后的头
reversedEnd.Next = next          // 翻转后的尾指向下一组
2.2 递归法
2.2.1 算法思想

递归法采用分治策略：

  1. 检查当前是否有K个节点
  2. 如果有，翻转前K个节点
  3. 递归处理剩余节点
  4. 将翻转后的头与递归结果连接
2.2.2 递归流程图
flowchart TD
    A[reverseKGroupRecursive开始] --> B{检查边界条件}
    B -->|head为空或k<=1| C[返回head]
    B -->|正常情况| D[检查是否有k个节点]
    D --> E{节点数量 >= k?}
    E -->|否| F[返回head，不翻转]
    E -->|是| G[翻转前k个节点]
    G --> H[递归处理剩余节点]
    H --> I[连接翻转结果与递归结果]
    I --> J[返回翻转后的头]
    
    style A fill:#e1f5fe
    style C fill:#c8e6c9
    style F fill:#c8e6c9
    style J fill:#c8e6c9
    style G fill:#fff3e0
2.2.3 递归调用栈分析
graph TD
    subgraph "递归调用栈示例: k=2, head=[1,2,3,4,5,6]"
        A[reverseKGroup[1,2,3,4,5,6]] --> B[翻转[1,2] -> [2,1]]
        B --> C[递归: reverseKGroup[3,4,5,6]]
        C --> D[翻转[3,4] -> [4,3]]
        D --> E[递归: reverseKGroup[5,6]]
        E --> F[翻转[5,6] -> [6,5]]
        F --> G[递归: reverseKGroup[]]
        G --> H[返回[]]
        H --> I[连接: [6,5] + []]
        I --> J[连接: [4,3] + [6,5]]
        J --> K[连接: [2,1] + [4,3,6,5]]
        K --> L[最终结果: [2,1,4,3,6,5]]
    end

递归终止条件：

  • head == nil：空链表
  • k <= 1：无需翻转
  • count < k：节点数量不足

递归逻辑：

  1. 检查数量：遍历K步统计节点数量
  2. 翻转前K个：调用reverseFirstK翻转
  3. 递归处理：head.Next = reverseKGroupRecursive(curr, k)
  4. 返回结果：return reversedHead
2.3 优化迭代法
2.3.1 算法思想

优化迭代法在标准迭代法基础上进行改进：

  1. 减少不必要的节点遍历
  2. 优化翻转函数的返回值
  3. 简化连接逻辑
2.3.2 优化对比
graph LR
    subgraph "标准迭代法"
        A[遍历到end节点] --> B[翻转[start, end]]
        B --> C[返回头和尾]
        C --> D[复杂连接逻辑]
    end
    
    subgraph "优化迭代法"
        E[直接计数k个] --> F[翻转k个节点]
        F --> G[返回新头]
        G --> H[简单连接逻辑]
    end
    
    A -.->|"需要end节点引用"| B
    E -.->|"只需计数"| F

优化点分析：

  1. 减少遍历：直接计数而不是遍历到end
  2. 简化翻转：只返回新头，不返回尾
  3. 简化连接：利用原start节点作为连接点

3. 算法复杂度分析

3.1 时间复杂度分析
graph TD
    A[链表长度n] --> B[迭代法]
    A --> C[递归法]
    A --> D[优化迭代法]
    
    B --> E[O(n): 每个节点访问2次]
    C --> F[O(n): 每个节点访问2次]
    D --> G[O(n): 每个节点访问2次]
    
    subgraph "详细分析"
        H[分组数量: n/k] --> I[每组翻转: O(k)]
        I --> J[总复杂度: O(n/k × k) = O(n)]
        K[额外遍历: O(n)] --> L[总复杂度: O(2n) = O(n)]
    end

详细计算：

  • 链表长度为n，分组大小为k
  • 分组数量：⌈n/k⌉
  • 每组翻转：O(k)
  • 翻转总时间：O(n/k × k) = O(n)
  • 额外遍历时间：O(n)
  • 总时间复杂度：O(n)
3.2 空间复杂度分析
graph TD
    A[空间复杂度] --> B[迭代法]
    A --> C[递归法]
    A --> D[优化迭代法]
    
    B --> E[O(1): 常数个指针变量]
    C --> F[O(n/k): 递归调用栈深度]
    D --> G[O(1): 常数个指针变量]
    
    subgraph "空间使用对比"
        H[迭代法: dummy + prev + start + end + next] --> I[5个变量 = O(1)]
        J[递归法: 递归栈深度] --> K[最坏情况: n/k层 = O(n/k)]
        L[优化法: dummy + prev + start + curr] --> M[4个变量 = O(1)]
    end

空间使用详情：

  • 迭代法：O(1)

    • dummy：虚拟头节点
    • prev：前驱指针
    • start：当前组起始节点
    • end：当前组结束节点
    • next：下一组起始节点

  • 递归法：O(n/k)

    • 递归调用栈深度：n/k层
    • 每层保存函数参数和局部变量

  • 优化迭代法：O(1)

    • 与标准迭代法相同
    • 减少了end和next变量

4. 边界条件处理

4.1 边界情况分类
边界条件
k值边界
链表长度边界
特殊输入边界
k <= 1
k = n
k > n
空链表
单节点链表
节点数 < k
head = nil
k = 0
k = 1
4.2 详细边界处理
4.2.1 k值边界处理
if head == nil || k <= 1 {
    return head
}
  • k <= 1：无需翻转，直接返回
  • k = 1：每个节点单独翻转，结果与原链表相同
  • k = n：整个链表翻转
4.2.2 链表长度边界处理
// 检查是否有k个节点
count := 0
curr := head
for count < k && curr != nil {
    curr = curr.Next
    count++
}

if count < k {
    // 不足k个，不翻转
    return head
}
  • 空链表：直接返回nil
  • 单节点链表：k>1时不翻转
  • 节点数 < k：不翻转，保持原顺序
4.2.3 特殊边界测试用例
graph LR
    A[边界测试] --> B[k=1]
    A --> C[k=链表长度]
    A --> D[k>链表长度]
    A --> E[空链表]
    A --> F[单节点]
    
    B --> G[[1,2,3] → [1,2,3]]
    C --> H[[1,2,3] → [3,2,1]]
    D --> I[[1,2,3] → [1,2,3]]
    E --> J[[] → []]
    F --> K[[1] → [1]]

5. 算法优化策略

5.1 性能优化
5.1.1 减少重复遍历
// 优化前：每次都要遍历到end
end := prev
for i := 0; i < k && end.Next != nil; i++ {
    end = end.Next
}

// 优化后：直接计数
count := 0
curr := prev.Next
for count < k && curr != nil {
    curr = curr.Next
    count++
}
5.1.2 优化翻转函数
// 优化前：返回头和尾
reversedStart, reversedEnd := reverseList(start, end)
prev.Next = reversedStart
reversedEnd.Next = next

// 优化后：只返回头，利用原start
reversedStart := reverseKNodes(start, k)
prev.Next = reversedStart
start.Next = curr  // start现在是翻转后的尾
5.2 代码优化
5.2.1 使用常量
const (
    MIN_K_VALUE = 1
    MAX_K_VALUE = 5000
    MAX_NODES = 5000
)
5.2.2 提前返回
// 提前检查边界条件
if head == nil || k <= 1 {
    return head
}

// 提前检查节点数量
if count < k {
    return head
}

6. 实际应用场景

6.1 数据分块处理
  • 场景：大数据集需要分块处理
  • 应用：数据库查询优化、文件传输
  • 示例：每1000条记录为一组进行批量操作
6.2 网络协议实现
  • 场景：数据包的分组传输
  • 应用：TCP/IP协议、HTTP请求
  • 示例：将长消息分成固定长度的数据包
6.3 算法优化
  • 场景：需要分组处理的数据结构
  • 应用：排序算法、搜索算法
  • 示例：归并排序中的分组合并

7. 常见错误与陷阱

7.1 分组边界错误
错误的分组边界
没有正确检查剩余节点
翻转了不足k个的节点
结果错误
正确的分组边界
准确检查每组节点数量
只翻转完整的k个节点
结果正确

错误示例：

// 错误：没有检查剩余节点数量
for prev.Next != nil {
    // 直接翻转，可能翻转不足k个节点
    start := prev.Next
    end := start
    for i := 1; i < k && end.Next != nil; i++ {
        end = end.Next
    }
    // 没有检查是否真的翻转了k个节点
}
7.2 节点连接错误
  • 问题：翻转后没有正确连接相邻组
  • 后果：链表断裂或形成环
  • 解决：仔细维护翻转前后的连接关系
7.3 递归深度问题
  • 问题：对于很长的链表，递归调用栈可能溢出
  • 后果：程序崩溃
  • 解决：使用迭代法或限制递归深度

8. 测试策略

8.1 单元测试设计
测试策略
功能测试
边界测试
性能测试
异常测试
正常分组翻转
不同k值测试
k=1边界
k=链表长度边界
空链表边界
大链表性能
异常输入值
8.2 测试用例覆盖

功能测试用例：

  1. [1,2,3,4,5], k=2 → [2,1,4,3,5]：标准偶数分组
  2. [1,2,3,4,5], k=3 → [3,2,1,4,5]：标准奇数分组
  3. [1,2,3,4,5,6], k=2 → [2,1,4,3,6,5]：完整分组

边界测试用例：

  1. [1,2,3,4,5], k=1 → [1,2,3,4,5]：k=1边界
  2. [1,2,3,4,5], k=5 → [5,4,3,2,1]：k=链表长度边界
  3. [1,2,3], k=4 → [1,2,3]：k>链表长度边界

异常测试用例：

  1. nil, k=2 → nil：空指针
  2. [1], k=0 → [1]：k=0边界
  3. [1,2,3,4,5], k=6 → [1,2,3,4,5]：k过大

9. 代码实现要点

9.1 关键代码段分析
func reverseKGroup(head *ListNode, k int) *ListNode {
    // 1. 边界条件检查
    if head == nil || k <= 1 {
        return head
    }
    
    // 2. 创建虚拟头节点
    dummy := &ListNode{Next: head}
    prev := dummy
    
    // 3. 主循环处理每组
    for {
        // 4. 检查剩余节点数量
        end := prev
        for i := 0; i < k && end.Next != nil; i++ {
            end = end.Next
        }
        if end.Next == nil && prev.Next != end {
            break
        }
        
        // 5. 翻转当前组
        start := prev.Next
        next := end.Next
        reversedStart, reversedEnd := reverseList(start, end)
        
        // 6. 重新连接
        prev.Next = reversedStart
        reversedEnd.Next = next
        
        // 7. 移动到下一组
        prev = reversedEnd
    }
    
    return dummy.Next
}
9.2 代码质量要求

可读性：

  • 变量命名清晰：start, end, next, reversedStart, reversedEnd
  • 注释详细：每个步骤都有说明
  • 结构清晰：逻辑分明的代码块

健壮性：

  • 边界条件检查完整
  • 指针操作安全
  • 异常情况处理

可维护性：

  • 函数职责单一
  • 代码复用性好
  • 易于扩展和修改

10. 总结与展望

10.1 算法特点总结

优势：

  1. 时间复杂度优秀：O(n)，每个节点最多访问2次
  2. 空间复杂度可控：迭代法O(1)，递归法O(n/k)
  3. 实现相对简单：逻辑清晰，易于理解
  4. 适用性广泛：可以处理各种长度的链表和k值

局限性：

  1. 只能按固定大小分组：无法处理变长分组
  2. 递归版本有栈溢出风险：对于很长的链表
  3. 指针操作复杂：需要仔细处理翻转前后的连接关系
10.2 扩展思考

变种问题：

  1. 变长分组翻转：每组节点数量不同
  2. 交替分组翻转：奇数组翻转，偶数组保持
  3. 条件分组翻转：根据节点值决定是否翻转

优化方向：

  1. 并行处理：对于超长链表，可以考虑并行处理不同组
  2. 缓存优化：利用CPU缓存特性优化访问模式
  3. 内存池：减少频繁的内存分配和释放
10.3 学习建议
  1. 理解分组思想：这是分治算法的基础
  2. 掌握区间翻转：链表操作的核心技巧
  3. 注意边界处理：特别是最后不足k个节点的情况
  4. 实践验证：多写测试用例验证正确性
  5. 总结规律：找出解题的通用模式

这道题是链表操作和分治算法的经典题目，通过深入理解其解题思路，可以掌握：

  • 链表分组处理技巧
  • 区间翻转算法
  • 分治递归思想
  • 边界条件处理

为后续更复杂的链表问题和分治算法打下坚实基础。

本仓库 25/main.go 提供了三种完整的实现方式，并在 main() 函数中包含了全面的测试用例，可以直接运行验证算法的正确性。

完整题解代码

package main

import (
	"fmt"
)

type ListNode struct {
	Val  int
	Next *ListNode
}

// reverseKGroup 迭代法：K个一组翻转链表
// 时间复杂度: O(n)；空间复杂度: O(1)
func reverseKGroup(head *ListNode, k int) *ListNode {
	if head == nil || k <= 1 {
		return head
	}

	dummy := &ListNode{Next: head}
	prev := dummy

	for {
		// 检查是否还有k个节点
		count := 0
		curr := prev.Next
		for count < k && curr != nil {
			curr = curr.Next
			count++
		}

		if count < k {
			// 剩余节点不足k个，不翻转
			break
		}

		// 翻转当前k个节点
		start := prev.Next
		reversedStart := reverseKNodes(start, k)

		// 重新连接
		prev.Next = reversedStart
		start.Next = curr

		// 移动到下一组
		prev = start
	}

	return dummy.Next
}

// reverseKNodes 翻转k个节点，返回新的头节点
func reverseKNodes(head *ListNode, k int) *ListNode {
	var prev *ListNode
	curr := head
	count := 0

	for count < k && curr != nil {
		next := curr.Next
		curr.Next = prev
		prev = curr
		curr = next
		count++
	}

	return prev
}

// reverseKGroupRecursive 递归法：K个一组翻转链表
func reverseKGroupRecursive(head *ListNode, k int) *ListNode {
	if head == nil || k <= 1 {
		return head
	}

	// 检查是否有k个节点
	count := 0
	curr := head
	for count < k && curr != nil {
		curr = curr.Next
		count++
	}

	if count < k {
		// 不足k个，不翻转
		return head
	}

	// 翻转前k个节点
	reversedHead := reverseFirstK(head, k)

	// 递归处理剩余节点
	head.Next = reverseKGroupRecursive(curr, k)

	return reversedHead
}

// reverseFirstK 翻转链表的前k个节点
func reverseFirstK(head *ListNode, k int) *ListNode {
	var prev *ListNode
	curr := head
	count := 0

	for count < k && curr != nil {
		next := curr.Next
		curr.Next = prev
		prev = curr
		curr = next
		count++
	}

	return prev
}

// reverseKGroupOptimized 优化迭代法：减少不必要的遍历
func reverseKGroupOptimized(head *ListNode, k int) *ListNode {
	if head == nil || k <= 1 {
		return head
	}

	dummy := &ListNode{Next: head}
	prev := dummy

	for {
		// 检查剩余节点数量
		count := 0
		curr := prev.Next
		for count < k && curr != nil {
			curr = curr.Next
			count++
		}

		if count < k {
			break
		}

		// 翻转当前k个节点
		start := prev.Next
		reversedStart := reverseKNodes(start, k)

		// 重新连接
		prev.Next = reversedStart
		start.Next = curr

		// 移动到下一组
		prev = start
	}

	return dummy.Next
}

// 辅助：从切片构造链表
func buildList(vals []int) *ListNode {
	if len(vals) == 0 {
		return nil
	}
	head := &ListNode{Val: vals[0]}
	curr := head
	for i := 1; i < len(vals); i++ {
		curr.Next = &ListNode{Val: vals[i]}
		curr = curr.Next
	}
	return head
}

// 辅助：链表转切片
func listToSlice(head *ListNode) []int {
	res := []int{}
	for head != nil {
		res = append(res, head.Val)
		head = head.Next
	}
	return res
}

func main() {
	// 示例1: head=[1,2,3,4,5], k=2 -> [2,1,4,3,5]
	h1 := buildList([]int{1, 2, 3, 4, 5})
	ans1 := reverseKGroup(h1, 2)
	fmt.Printf("示例1 (k=2): %v\n", listToSlice(ans1))

	// 示例2: head=[1,2,3,4,5], k=3 -> [3,2,1,4,5]
	h2 := buildList([]int{1, 2, 3, 4, 5})
	ans2 := reverseKGroup(h2, 3)
	fmt.Printf("示例2 (k=3): %v\n", listToSlice(ans2))

	// 测试递归版本
	h3 := buildList([]int{1, 2, 3, 4, 5, 6})
	ans3 := reverseKGroupRecursive(h3, 2)
	fmt.Printf("递归版 (k=2): %v\n", listToSlice(ans3))

	// 测试优化版本
	h4 := buildList([]int{1, 2, 3, 4, 5, 6, 7, 8})
	ans4 := reverseKGroupOptimized(h4, 3)
	fmt.Printf("优化版 (k=3): %v\n", listToSlice(ans4))

	// 边界测试：k=1
	h5 := buildList([]int{1, 2, 3, 4, 5})
	ans5 := reverseKGroup(h5, 1)
	fmt.Printf("边界测试 (k=1): %v\n", listToSlice(ans5))

	// 边界测试：k等于链表长度
	h6 := buildList([]int{1, 2, 3, 4, 5})
	ans6 := reverseKGroup(h6, 5)
	fmt.Printf("边界测试 (k=5): %v\n", listToSlice(ans6))
}
博客
使用Go语言实现线程安全的Map
11-25 779
自定义线程安全的SyncMap泛型支持：灵活适配不同类型的键值。线程安全：支持高并发场景的安全访问。可扩展性：易于添加更多功能，如合并操作、条件更新等。通过本文的实现与示例，希望您能更好地理解和应用线程安全Map，构建健壮的并发应用。
博客
使用 Go 语言封装 MinIO 相关操作
11-24 966
MinIO 是一个高性能的对象存储服务，兼容 Amazon S3 API，广泛用于存储和管理海量数据。在实际开发中，封装一个便于使用的 MinIO 操作包，可以帮助我们简化操作逻辑，提高代码的可读性和复用性。初始化 MinIO 客户端上传文件下载文件列出文件删除文件获取文件的预签名 URL通过封装 MinIO 的常用操作，我们可以极大简化代码逻辑，提高开发效率。在实际项目中，可以根据需求进一步扩展功能，例如支持更多的操作、增加日志功能或通过配置文件动态加载参数等。
博客
Go语言开发的源代码行数统计工具
11-21 1209
是一个开源工具，用于统计各种编程语言的源代码文件数量和代码行数。它支持多种语言，易于扩展以包括自定义语言。简单易用，可以帮助开发者快速了解代码库并跟踪变化。页面下载预编译的二进制文件。
博客
使用gRPC基于Protobuf传输大文件或数据流
05-10 2538
在gRPC中，服务和消息的定义是通过.proto文件进行的。例如，定义一个文件传输服务，可以在这里定义了一个服务，包含了一个Upload方法，该方法接受一个FileChunk类型的流，并返回一个状态。
博客
极光推送Go语言服务端SDK
12-31 1163
jpush-api-golang-client项目地址：https://github.com/Scorpio69t/jpush-api-golang-client概述JPush’s Golang client library for accessing JPush APIs. 极光推送的 Golang 版本服务器端 SDK。该项目参考ylywyn结合极光推送官方文档而来。(原项目年久失修，有很多新特性都没有提供，本项目旨在将其完善，方便大家使用，后续会持续更新，不足之处欢迎大家指正，谢谢~)参考R
博客
HackRF-AIS信号的采集与解调
10-25 2155
目录AIS信号采集与解调1、硬件设备2、系统准备3、软件准备4、进行实验（需要去有船只经过的江边才能采集到信号，本次实验于重庆嘉陵江边进行）5、AIS信息解译AIS解调后数据源可去一下连接获取AIS信号采集与解调1、硬件设备​ 硬件设备采用HackRF One，HackRF是一款全开源的硬件项目，其目的主要是为了提供廉价的SDR(软件定义无线电)方案，作者Mike Ossmann在第一版HackRF Jawbreaker时通过Kickstart融资成功，之后Mike Ossmann开始进行了第二版Ha
博客
c/c++ 实现三角函数（不使用库函数） sin/cos/tan/cot
03-23 4745
在许多嵌入式系统或计算平台中，可能不方便使用标准数学库函数。在本篇博客中，我们将使用 泰勒展开 来实现常见的三角函数：sin(x)、cos(x)、tan(x) 和 cot(x)，而不依赖任何库函数。通过手动实现这些数学公式，我们可以更好地理解三角函数的计算原理，同时为那些受限的环境提供一种实现方案。泰勒展开是数学中一个非常重要的公式，它能够将任何在某点可导的函数展开为一个无限级数。对于三角函数，我们可以利用其在0点的泰勒级数展开来近似计算函数值。sinxx−x33!x55!−。
博客
【LeetCode】24. 两两交换链表中的节点
08-23 619
本文介绍了链表两两节点交换的三种解法：迭代法、递归法和优化迭代法。迭代法通过维护三个指针（prev、first、second）逐步交换相邻节点；递归法采用自底向上策略处理子问题；优化迭代法利用多重赋值简化代码。三种方法的时间复杂度均为O(n)，空间复杂度分别为O(1)、O(n)和O(1)。关键点在于正确处理节点引用关系，确保链表不断裂，并注意边界条件如空链表或单节点情况。
博客
【LeetCode】22. 括号生成
08-22 1111
本文介绍了生成有效括号组合的三种方法：回溯剪枝、动态规划和卡塔兰数验证。回溯法通过约束左右括号的数量来生成所有有效解；动态规划利用"(A)B"的结构递归构造解；卡塔兰数则用于验证解的数量正确性。对于n=3的情况，输出包括((()))等5种组合。三种方法的时间复杂度均为O(Cn)（Cn为卡塔兰数），空间复杂度从O(n)到O(Cn)不等。文末提供了Go语言实现代码，展示了三种方法在n=1-4时的输出一致性验证。
博客
【LeetCode】21. 合并两个有序链表
08-22 989
摘要：本文介绍了合并两个有序链表的三种解法。推荐使用迭代-哨兵节点法（时间复杂度O(m+n)，空间O(1)），通过比较节点值逐步连接较小节点。递归法代码简洁但空间复杂度较高（O(m+n)）。文中提供了完整Go代码实现、测试用例及流程图解，演示了如何正确处理边界条件（空链表、负数、重复值等）并保持结果升序性。三种解法均通过测试验证，其中迭代法最优，适合实际应用。
博客
【LeetCode】19. 删除链表的倒数第 N 个结点
08-21 991
本文介绍了删除链表倒数第N个节点的三种解法，重点推荐双指针法。通过设置哑结点统一处理边界情况，快指针先走N步后，快慢指针同步移动，当快指针到尾时慢指针指向待删节点的前驱。代码实现包含链表构建和转换工具函数，并验证了三个示例（删除中间、尾部和头节点）。时间复杂度O(sz)，空间复杂度O(1)。
博客
【LeetCode】18. 四数之和
08-21 891
本文介绍了求解"四数之和"问题的两种算法：排序+双指针法和通用的kSum递归法。双指针法通过三层循环固定两个数，用双指针在剩余区间搜索，时间复杂度O(n³)。kSum法则将问题抽象为递归框架，当k=2时使用双指针解决。两种方法都通过排序、去重和剪枝优化性能，并处理了大数溢出问题。文章提供了详细的流程图解和代码实现要点，包括去重逻辑、剪枝策略和long类型处理等关键细节。示例代码展示了两种解法的具体实现，帮助理解如何高效解决这类组合求和问题。
博客
【LeetCode】17. 电话号码的字母组合
08-19 1219
题目要求根据电话号码数字（2-9）生成所有可能的字母组合。采用回溯算法，通过递归枚举每个数字对应的字母，逐步构建组合。时间复杂度为O(4^n)，空间复杂度O(n)。关键步骤包括：数字-字母映射、递归回溯生成组合、处理边界情况（如空输入）。示例输入"23"输出["ad","ae","af","bd","be","bf","cd","ce&qu
博客
【LeetCode】16. 最接近的三数之和
08-19 848
这道题要求从数组中找出三个数，使其和最接近目标值。核心解法是排序+双指针：先排序数组，然后固定一个数，用双指针寻找另外两个数，计算三数之和与目标的差值，不断更新最接近值。时间复杂度为O(n²)，空间复杂度O(1)。关键优化包括跳过重复元素和剪枝处理。该算法适用于数值逼近、优化问题等场景，是经典的双指针应用范例。
博客
【LeetCode】15. 三数之和
08-18 382
本文介绍了求解三数之和问题的两种方法。题目要求在给定整数数组中找到所有不重复的三元组，使其元素之和为零。推荐的方法是排序+双指针：先对数组排序，然后固定一个元素，使用双指针在剩余区间寻找两数之和的补数，同时通过跳过重复值来避免重复解。该方法时间复杂度为O(n²)，空间复杂度为O(1)。另一种备选方法是排序后使用哈希集合辅助查找，但实现较复杂。文中提供了Go语言实现代码，包含详细注释和测试用例，特别强调了去重处理和边界条件的注意事项。
博客
【LeetCode】14. 最长公共前缀
08-18 429
输入：strs = [“interspecies”,“interstellar”,“interstate”]：O(S × log m)，其中S是所有字符串中字符数量的总和，m是字符串数组中的字符串的最小长度。：O(m log n)，其中m是字符串数组中的字符串的平均长度，n是字符串的数量。输入：strs = [“flower”,“flow”,“flight”]输入：strs = [“dog”,“racecar”,“car”]：O(S)，其中S是所有字符串中字符数量的总和。第0列: f,f,f ✓。
博客
【LeetCode】13. 罗马数字转整数
08-17 871
本文介绍了将罗马数字转换为整数的算法，重点处理特殊减法规则（如IV=4、IX=9等）。通过从右向左遍历字符串，比较相邻字符值，当较小值位于较大值左侧时执行减法操作。算法采用O(n)时间复杂度和O(1)空间复杂度，提供多种解法对比，并包含流程图展示转换过程（如"MCMXCIV"转为1994）。关键优化包括遍历方向选择、数组映射替代哈希表，适用于时钟、章节编号等实际场景。
博客
【LeetCode】12. 整数转罗马数字
08-17 1042
本文介绍了将整数转换为罗马数字的算法，重点分析了贪心算法的实现过程。罗马数字转换遵循特定规则，包括基本符号对应关系（I=1,V=5等）、减法规则（如4=IV,9=IX）和重复限制（符号最多连续出现3次）。文章通过流程图展示了转换过程，对比了不同解法的优劣，推荐使用时间复杂度O(1)的贪心算法。该算法通过从大到小遍历预定义的符号值数组，逐步构建结果字符串。应用场景包括时钟显示、章节编号等。测试用例应覆盖基础功能、边界值（1-3999）和特殊规则（4/9相关转换）。
博客
【LeetCode】10. 正则表达式匹配
08-17 960
本文介绍了正则表达式匹配问题的动态规划解法。题目要求实现支持"."和""的正则匹配，其中"."匹配任意字符，""匹配零或多个前驱字符。通过二维DP表记录状态转移，处理字符匹配、星号处理和通配符三种情况。解法分析表明，动态规划方法时间复杂度为O(mn)，空间复杂度可优化至O(n)。文章详细阐述了DP表构建过程、边界条件处理和优化策略，并对比了不同解法的优劣。该算法在文本处理、数据验证等场景有重要应用，通过合理设计测试用例可验证其正
博客
【LeetCode】9. 回文数
08-17 923
本文介绍如何判断一个整数是否为回文数。回文数是指正序和倒序读相同的整数（如121）。解题思路包括数学反转法（推荐）和字符串双指针法。数学方法只反转数字后半部分，时间复杂度O(log n)，空间O(1)；字符串法直观但需要额外空间。关键优化点在于处理负数、零值和特殊边界条件，如以0结尾的非零数直接判否。文章通过流程图和复杂度分析对比了不同解法，并提供了测试用例设计建议，强调负数处理等核心边界条件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值