leetcode 刷题笔记1-5
leetcode 刷题笔记1-5
- 1
- 2
- 3
- 4
- 5
浑浑噩噩过了好久，刷一刷leetcode吧，创了个博客也写一下思路，也督促自己多刷一点，以前没经过系统训练，希望大佬们多多指点。
1
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
思路1
首先想到的思路就是暴力遍历法，遍历每一个元素，查找该元素后面的元素是否满足条件。
c代码
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
#include
int* twoSum(int* nums, int numsSize, int target) {
int i = 0;
int j = 1;
int *result = (int *)malloc(2 * sizeof(int));
for (j = 1; j < numsSize; j++)
{
for (i = 0; i < j; i++)
{
if (nums[i] + nums[j] == target)
{
result[0] = i;
result[1] = j;
return result;
}
}
}
return 0;
}
时间复杂度为 O ( n 2 ) O(n^2) O(n2)，空间复杂度为 O ( 1 ) O(1) O(1)。
思路2
运用hash思想，第一次将数组中每个数字和序号存入map，第二次遍历hash，查询每个值的目标元素是否在map中。
c++代码
class Solution {
public:
vector twoSum(vector& nums, int target)
{
int size = nums.size();
map myMap;
vector arr;
for (int i = 0; i < size; i++)
{
myMap[nums[i]] = i;
}
for (int i = 0; i < size; i++)
{
map::iterator iter;
iter = myMap.find(target - nums[i]);
if (iter != myMap.end())
{
if (iter->second != i)
{
arr.push_back(i);
arr.push_back(iter->second);
return arr;
}
}
}
return arr;
}
};
时间复杂度为 O ( n ) O(n) O(n)，空间复杂度为 O ( n ) O(n) O(n)。
思路3
其实和思路二差不多，只是使用一遍哈希，把上面两步哈希的工作放到一步中，在将元素插入表中的同时查找表中是否存在当前元素的目标元素。
class Solution {
public:
vector twoSum(vector& nums, int target)
{
int size = nums.size();
map myMap;
vector arr;
for (int i = 0; i < size; i++)
{
map::iterator iter;
iter = myMap.find(target - nums[i]);
if (iter != myMap.end())
{
if (iter->second != i)
{
arr.push_back(iter->second);
arr.push_back(i);
return arr;
}
}
myMap[nums[i]] = i;
}
return arr;
}
};
时间复杂度为 O ( n ) O(n) O(n)，空间复杂度为 O ( n ) O(n) O(n)
2
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807
思路1
第一反应是分别把两个数表示出来，然后返回直接相加。。。。。，结果好像因为数太大溢出了，还是贴一下代码。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2)
{
int nums1 = 0;
int nums2 = 0;
ListNode *result = NULL;
ListNode *p = result;
int ans;
ListNode *ptr1 = l1;
ListNode *ptr2 = l2;
int i = 1;
while (ptr1 != NULL)
{
nums1 += i * (ptr1->val);
ptr1 = ptr1->next;
i *= 10;
}
i = 1;
while (ptr2 != NULL)
{
nums2 += i * (ptr2->val);
ptr2 = ptr2->next;
i *= 10;
}
ans = nums1 + nums2;
while (ans >= 1)
{
int n = ans % 10;
ans /= 10;
if (result == NULL)
{
result = new ListNode(n);
p = result;
}
else
{
p->next = new ListNode(n);
p = p->next;
}
}
return result;
}
};
思路2
思路二就是按照小学里老师教我们加法竖式的方法，只不过左右相反，从左往右相加，大于10就往后进1。可以用一个bool型变量flag表示是否进位，注意在循环最后如果flag为真还要再加上1。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2)
{
ListNode *result = NULL;
ListNode *p;
ListNode *ptr1 = l1;
ListNode *ptr2 = l2;
bool flag = false;
while(ptr1 != NULL || ptr2 != NULL)
{
int a, b, sum;
if (ptr1 != NULL)
{
a = ptr1->val;
}
else
{
a = 0;
}
if (ptr2 != NULL)
{
b = ptr2->val;
}
else
{
b = 0;
}
sum = a + b;
if (flag)
{
sum += 1;
}
flag = sum / 10;
if (result == NULL)
{
result = new ListNode(sum % 10);
p = result;
}
else
{
p->next = new ListNode(sum % 10);
p = p->next;
}
if (ptr1 != NULL)
{
ptr1 = ptr1->next;
}
if (ptr2 != NULL)
{
ptr2 = ptr2->next;
}
}
if (flag)
{
p->next = new ListNode(1);
}
return result;
}
};
时间复杂度为 O ( m a x ( m , n ) ) O(max(m,n)) O(max(m,n))，空间复杂度为 O ( m a x ( m , n ) ) O(max(m,n)) O(max(m,n))。
3
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例
输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
思路1
第一种思路还是我最喜欢的暴力法，先写一个判定函数，判定一个字符串中是否存在重复字符，然后从第一个字符开始，向后遍历，对该字符串每一个子串进行判定，得到最大子串长度（完全没有想。。。然后需要三个大循环 O ( n 3 ) O(n^3) O(n3)的时间复杂度。。。然后超时了）。
class Solution {
public:
int lengthOfLongestSubstring(string s)
{
int len = s.size();
int res = 0;
if (len == 1)
{
return 1;
}
for (int i = 0; i < len; i++)
{
for (int j = i + 1; j < len + 1; j++)
{
int max_t = 0;
string stmp(s.begin() + i,s.begin() + j);
bool isUniq = isUnique(stmp);
if (isUniq == true)
{
max_t = stmp.size();
if (res < max_t)
{
res = max_t;
}
}
}
}
return res;
}
bool isUnique(string s)
{
int size = s.size();
for (int i = size - 1; i > 0; i--)
{
string strtmp (s, 0, i);
string::size_type postion = strtmp.find(s[i]);
if (postion != string::npos)
{
return false;
}
}
return true;
}
};
思路2
思路二我们试着优化一下思路一的算法，首先我们还是通过一次大循环，来遍历子串的首字符索引i，然后用j遍历子串的末字符后一位索引，如果 s [ j ] s[j] s[j]不存在于 s [ i , j ] s[i,j] s[i,j]中，则j加1，如果存在，则直接跳出循环。
class Solution {
public:
int lengthOfLongestSubstring(string s)
{
int len = s.size();
int res = 0;
for (int i = 0; i < len; i++)
{
int t_tmp = 1;
for (int j = i + 1; j < len; j++)
{
string stmp(s.begin() + i, s.begin() + j);
if (stmp.find(s[j]) != string::npos)
{
break;
}
t_tmp++;
}
if (res < t_tmp)
{
res = t_tmp;
}
if (res + i >= len)
{
break;
}
}
return res;
}
};
思路3
思路二虽然通过了，但是时间空间复杂度还是较大，思路三使用了滑窗的思路。相当于指定头索引i，尾索引j，使j向后遍历，如果s[j]的字符在s[i-j]中存在，则将i子串中前一个重复的字符去掉，始终保证是无重复子串。
class Solution
{
public:
int lengthOfLongestSubstring(string s)
{
int size = s.size();
int i = 0;
int j = 1;
int res = 0;
if (size == 1)
{
return 1;
}
while(j <= size)
{
string strtmp(s.begin() + i, s.begin() + j);
if (strtmp.find(s[j]) != string::npos)
{
i = i + strtmp.find(s[j]) + 1;
}
j++;
if (res < strtmp.size())
{
res = strtmp.size();
}
}
return res;
}
};
4
给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。
请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。
你可以假设 nums1 和 nums2 不会同时为空。
示例
nums1 = [1, 3]
nums2 = [2]
则中位数是 2.0
nums1 = [1, 2]
nums2 = [3, 4]
则中位数是 (2 + 3)/2 = 2.5
思路1
思路一暂时不考虑时间复杂度的要求，看到题目直觉上就是使用归并算法的思想，首先新建一个数组，依次两个有序数列的第一个数，将小的数放入新建的数组，排序后按数组总长度的奇偶分类计算中位数 。
class Solution {
public:
double findMedianSortedArrays(vector &nums1, vector &nums2)
{
vector arr;
int l = 0, r = 0;
while (arr.size() < nums1.size() + nums2.size())
{
if (r >= nums2.size())
{
arr.push_back(nums1[l++]);
}
else if (l >= nums1.size())
{
arr.push_back(nums2[r++]);
}
else if (nums1[l] > nums2[r])
{
arr.push_back(nums2[r]);
r++;
}
else
{
arr.push_back(nums1[l]);
l++;
}
}
if (arr.size()%2)
{
return arr[arr.size() / 2];
}
else
{
return ((double)arr[arr.size() / 2] + arr[arr.size() / 2 - 1]) / 2;
}
}
};
思路2
思路2是借鉴了评论区大神的想法，中位数之前，之后分别有tot = (n+m-1)/2个数，我们假设这tot个数的分布情况为nums1中的前p个，和nums2中的前tot-p个。因为中位数大于每一个他前面的数，所以，如果nums1中的第p+1个数小于nums2中的第tot-p个数，则说明p过小。使用二分法寻找p即可。
class Solution {
public:
double findMedianSortedArrays(vector& nums1, vector& nums2) {
int n = nums1.size(), m = nums2.size();
if(!n && !m) return 0.0;
int pos = (n + m - 1) >> 1;
int l = max(0, pos - m), r = min(pos, n);
while(l < r){
int mid = (l + r) >> 1;
if(nums1[mid] < nums2[pos - mid - 1])
l = mid + 1;
else r = mid;
}
if((n + m) & 1) {
if(l >= n) return nums2[pos - l];
if(pos - l >= m) return nums1[l];
if(nums1[l] < nums2[pos - l]) return nums1[l];
return nums2[pos - l];
}else{
if(l >= n) return 0.5 * (nums2[pos - l] + nums2[pos - l + 1]);
if(pos - l >= m) return 0.5 * (nums1[l] + nums1[l + 1]);
if(pos - l + 1 < m && nums1[l] > nums2[pos - l + 1])
return 0.5 * (nums2[pos - l] + nums2[pos - l + 1]);
else if(l + 1 < n && nums2[pos - l] > nums1[l + 1])
return 0.5 * (nums1[l] + nums1[l + 1]);
else return 0.5 * (nums1[l] + nums2[pos - l]);
}
}
};
5
给定一个字符串s，找到s中最长的回文子串。你可以假设 s的最大长度为1000。
输入： “babad”
输出： “bab”
注意： “aba”也是一个有效答案。
输入： “cbbd”
输出： “bb”
思路1
依旧是暴力法，写出所有可能的子串，然后计算是否回文，有时候会超时。
class Solution {
public:
string longestPalindrome(string s) {
if (s == "")
{
return s;
}
string temp;
int size = s.size();
for (int len = size; len > 0; len--)
{
for (int i = 0; i <= size - len; i++)
{
if (s[i] != s[len + i - 1])
{
continue;
}
temp = s.substr(i, len);
string revtemp = temp;
reverse(revtemp.begin(), revtemp.end());
if (temp == revtemp)
{
return temp;
}
}
}
return "";
}
};
思路2
思路二是使用中心扩展法的思想.
class Solution {
public:
string longestPalindrome(string s) {
if (s == "" || s.size()== 1)
{
return s;
}
int size = s.size();
int start = 0;
int max = 1;
int len1 = 0, len2 = 0;
int len = 0;
for (int i = 0; i < size; i++)
{
len1 = retRomeLen(s, i, i);
len2 = retRomeLen(s, i, i + 1);
len = len1>len2 ? len1 : len2;
if (len > max)
{
max = len;
start = i - (len-1) / 2;
}
}
return s.substr(start, max);
}
int retRomeLen(string s, int left, int right)
{
while (left >= 0 && right < s.size() && s[left] == s[right] )
{
left--;
right++;
}
return right - left -1;
}
};