目录
K个⼀组翻转链表（hard）
题目解析
讲解算法原理
编写代码
两数之和（easy）
题目解析
讲解算法原理
编写代码
K个⼀组翻转链表（hard）
题目解析
1.题目链接：. - 力扣（LeetCode）
2.题目描述
给你链表的头节点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]
提⽰：链表中的节点数⽬为n1<=k<=n<=5000
0<=Node.val<=1000
进阶：你可以设计⼀个只⽤O(1)额外内存空间的算法解决此问题吗？
讲解算法原理
解法（模拟）：算法思路：
本题的⽬标⾮常清晰易懂，不涉及复杂的算法，只是实现过程中需要考虑的细节⽐较多。我们可以把链表按 K 个为⼀组进⾏分组，组内进⾏反转，并且记录反转后的头尾结点，使其可以和
前、后连接起来。思路⽐较简单，但是实现起来是⽐较复杂的。
我们可以先求出⼀共需要逆序多少组（假设逆序 n 组），然后重复 n 次⻓度为 k 的链表的逆序即可。
编写代码
c++算法代码：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution
{
public:
ListNode* reverseKGroup(ListNode* head, int k)
{
// 1. 先求出需要逆序多少组
int n = 0;
ListNode* cur = head;
while(cur)
{
cur = cur->next;
n++;
}
n /= k;
// 2. 重复 n 次：⻓度为 k 的链表的逆序即可
ListNode* newHead = new ListNode(0);
ListNode* prev = newHead;
cur = head;
for(int i = 0; i < n; i++)
{
ListNode* tmp = cur;
for(int j = 0; j < k; j++)
{
ListNode* next = cur->next;
cur->next = prev->next;
prev->next = cur;
cur = next;
}
prev = tmp;
}
// 把不需要翻转的接上
prev->next = cur;
cur = newHead->next;
delete newHead;
return cur;
}
};java算法代码：
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution
{
public ListNode reverseKGroup(ListNode head, int k)
{
// 1. 先求出需要逆序多少组
int n = 0;
ListNode cur = head;
while(cur != null)
{
cur = cur.next;
n++;
}
n /= k;
// 2. 重复 n 次：⻓度为 k 的链表的逆序 ListNode newHead = new ListNode(0); ListNode prev = newHead;
cur = head;
for(int i = 0; i < n; i++)
{
ListNode tmp = cur;
for(int j = 0; j < k; j++)
{
// 头插的逻辑
ListNode next = cur.next;
cur.next = prev.next;
prev.next = cur;
cur = next;
}
prev = tmp;
}
// 把后⾯不需要逆序的部分连接上
prev.next = cur;
return newHead.next;
}
}两数之和（easy）
题目解析
1.题目链接：. - 力扣（LeetCode）
有⼈相爱，有⼈夜⾥开⻋看海，有⼈leetcode第⼀题都做不出来。
2.题目描述
给定⼀个整数数组nums和⼀个整数⽬标值target，请你在该数组中找出和为⽬标值target的那两个整数，并返回它们的数组下标。
你可以假设每种输⼊只会对应⼀个答案。但是，数组中同⼀个元素在答案⾥不能重复出现。你可以按任意顺序返回答案。
⽰例1：
输⼊：nums=[2,7,11,15],target=9
输出：[0,1]
解释：因为nums[0]+nums[1]==9，返回[0,1]。
⽰例3：
输⼊：nums=[3,3],target=6
输出：[0,1]
讲解算法原理
解法（哈希表）：
算法思路：
• 如果我们可以事先将「数组内的元素」和「下标」绑定在⼀起存⼊「哈希表」中，然后直接在哈希
表中查找每⼀个元素的 target - nums[i] ，就能快速的找到「⽬标和的下标」。• 这⾥有⼀个⼩技巧，我们可以不⽤将元素全部放⼊到哈希表之后，再来⼆次遍历（因为要处理元素
相同的情况）。⽽是在将元素放⼊到哈希表中的「同时」，直接来检查表中是否已经存在当前元素所对应的⽬标元素（即 target - nums[i] ）。如果它存在，那我们已经找到了对应解，并⽴即将其返回。⽆需将元素全部放⼊哈希表中，提⾼效率。
• 因为哈希表中查找元素的时间复杂度是 O(1) ，遍历⼀遍数组的时间复杂度为 O(N) ，因此可以
将时间复杂度降到 O(N) 。
这是⼀个典型的「⽤空间交换时间」的⽅式。
编写代码
c++算法代码：
class Solution
{
public:
vector<int> twoSum(vector<int>& nums, int target)
{
unordered_map<int, int> hash; // <nums[i], i>
for(int i = 0; i < nums.size(); i++)
{
int x = target - nums[i];
if(hash.count(x)) return {hash[x], i};
hash[nums[i]] = i;
}
// 照顾编译器
return {-1, -1};
}
};java算法代码：
class Solution
{
public int[] twoSum(int[] nums, int target)
{
Map<Integer, Integer> hash = new HashMap<>(); // <nums[i], i>
for(int i = 0; i < nums.length; i++)
{
int x = target - nums[i];
if(hash.containsKey(x))
{
return new int[]{i, hash.get(x)};
}
hash.put(nums[i], i);
}
// 照顾编译器
return new int[]{-1, -1};
}
}
