day06打卡
时间复杂度:O(N),空间复杂度:O(1)
第一想法:快慢指针追逐问题,当相遇时,再让一个指针从head处开始找,直到和环内的节点相遇,这个位置就是环的入口。
证明:忘记了,这几天补上
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode* fast = head, * slow = head;
while(fast && fast->next)
{
fast = fast->next->next;
slow = slow->next;
if(fast == slow)
{
//记录相遇点
ListNode* meet = fast;
while(head != meet)
{
head = head->next;
meet = meet->next;
}
return meet;
}
}
return NULL;
}
};
时间复杂度:O(N),空间复杂度:O(N)
第一想法:创建哈希表,遍历一遍字符串t,再遍历一遍s,看看哈希表中有没有不为0的映射值。
class Solution {
public:
bool isAnagram(string s, string t) {
int hash[26] = {0};
for(auto& e : t)
{
hash[e - 'a']++;
}
for(auto& e : s)
{
hash[e - 'a']--;
}
for(auto& e : hash)
{
if(e != 0)
return false;
}
return true;
}
};
时间复杂度:O(N),空间复杂度:O(N)
第一想法:创建哈希表,把nums1中的数,插入哈希表中,并全部置为1,再遍历nums2,从哈希表中查找相同的元素即可。
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
unordered_map<int, int> hash;
vector<int> ret;
for(auto& e : nums1)
{
hash[e] = 1;
}
for(auto& e : nums2)
{
if(hash[e] > 0)
{
hash[e] = 0;
ret.push_back(e);
}
}
return ret;
}
};
时间复杂度:O(logN),空间复杂度:O(1)
第一想法:有点没有头绪,忘记之前怎么写的了
看了题解:模仿环形链表即可,快慢指针找出相交的点,看是不是变成1造成的循环即可。
class Solution {
public:
int getVal(int n)
{
int val = 0;
while(n)
{
int tmp = n % 10;
val += tmp * tmp;
n /= 10;
}
return val;
}
bool isHappy(int n) {
int fast = getVal(n), slow = n;
while(fast != slow)
{
slow = getVal(slow);
fast = getVal(getVal(fast));
}
return slow == 1;
}
};
时间复杂度:O(N),空间复杂度:O(N)
第一想法:暴力解,O(N^2)太慢了
看了题解:创建一个哈希表,遍历这个nums,用当前的数找出新的newTarget:target - nums[0],从哈希表中找这个newTarget是否存在即可,最后将这个nums[i]插入哈希表。(向哈希表前查找)
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> hash;
for(int i = 0; i < nums.size(); i++)
{
int newTarget = target - nums[i];
if(hash.count(newTarget)) return {hash[newTarget], i};
hash[nums[i]] = i;
}
return {};
}
};