第23题 合并K个升序链表
思路：
采用递归，由于之前已经做过两个链表的合并（可见上一个），所以K个链表其实就是两个链表的升级版，只需要让第二个以及以后的链表与第一个相组合，组合结果加入第一个链表，最后返回第一个链表就可以。
C++代码：
class Solution
{
public:
ListNode *mergeTwoLists(ListNode *l1, ListNode *l2)
{
if (l1 == nullptr)
return l2;
if (l2 == nullptr)
return l1;
if (l1->val <= l2->val)
{
l1->next = mergeTwoLists(l1->next, l2);
return l1;
}
if (l1->val > l2->val)
{
l2->next = mergeTwoLists(l1, l2->next);
return l2;
}
return nullptr;
}
ListNode *mergeKLists(vector<ListNode *> &lists)
{
if(lists.empty()) return nullptr;
ListNode *ans = lists[0];
int n=lists.size();
for (int i = 1; i < n; i++)
{
ans= mergeTwoLists(ans, lists[i]);
}
return ans;
}
};
026 删除排序数组中的重复项
思路：
利用双指针，一个“快”指针，一个“慢”指针，遍历一遍数组，过程中，通过比较快指针与慢指针所对应的值比较，就可以得到去重的数组。应该可以在要求的O(1)内完成。
C++代码：
class Solution
{
public:
int removeDuplicates(vector<int> &nums)
{
if (nums.size() < 2)
return nums.size();
int i = 0;
for (int j = 0; j < nums.size(); j++)
{
if (nums[i] != nums[j])
{
i++;
nums[i] = nums[j];
}
}
return i+1;
}
};
033 搜索旋转排序数组
思路：
每太看懂这个题，直接遍历一遍，复杂度O(n)。二分法可能是O(logN)。二分法可能是题目需要的吧。
二分法：顾名思义就是不断二分，缩小范围，最后找到所需要的值。我用递归写一下二分法吧。
int BinarySearch(vector<int> nums, int l, int r, int target) //l,r分别为左右边界，target为查找的值.
{
if (l == r) //l==r是递归的出口
{
int ret = (nums[l] == target ? l : -1);
return ret; //判断数组中是否存在target，存在则返回索引，不存在则返回-1.
}
int mid = (l + r) / 2;
if (nums[l] < nums[mid]) //判断l~mid是否为递增序列
{
if (nums[l] <= target && nums[mid] >= target) //判断target是否在l~mid之间
return BinarySearch(nums, l, mid, target); //若在l~mid之间，让mid成为右端点。
return BinarySearch(nums, mid + 1, r, target); //若不在l~mid之间，则一定在mid+1~r之间,则让mid+1成为左端点。
}
else //mid+1~right之间为递增序列
{
if (nums[mid + 1] <= target && nums[r] >= target) //判断target是否在mid~r
return BinarySearch(nums, mid + 1, r, target); //若在mid~r,让mid变成左端点。
return BinarySearch(nums, l, mid, target); //若在l~mid,mid变成右端点。
}
}
本题代码C++：
class Solution
{
public:
int BinarySerch(vector<int> &nums, int left, int right, int target)
{
if (left == right)
{
int ret=(target==nums[left]?left:-1);
return ret;
}
int mid = (left + right) / 2;
if (nums[left] < nums[mid])
{
if (nums[left] <= target && nums[mid] >= target)
return BinarySerch(nums, left, mid, target);
return BinarySerch(nums, mid + 1, right, target);
}
else
{
if (nums[mid + 1] <= target && nums[right] >= target)
return BinarySerch(nums, mid + 1, right, target);
return BinarySerch(nums, left, mid, target);
}
}
int search(vector<int> &nums, int target)
{
if (nums.empty()) //注意！！这里一定要判断是否为空。
return -1;
return BinarySerch(nums, 0, nums.size() - 1, target);
}
};
