8.26 review

 

 

lc02.01

双重循环遍历，外层循环逐个拿节点，内层循环用前驱节点去对比、删除后续相同值节点，全程不使用额外存数据的临时缓冲区，靠“指针操作 + 嵌套遍历”直接在原链表删重复节点 

- 从头开始，每个节点都挨个跟后面节点比，一样就把后面那重复的删了，不用额外存东西，直接在原链表上删。

class Solution {
public:
ListNode* removeDuplicateNodes(ListNode* head) {
if(head==NULL) return NULL;
ListNode *p=head;
while(p!=NULL)

{//每遍历一个节点，就拿该节点之后的节点与之进行比较，如果相等，则将后面的这个节点删掉
ListNode *pre = p;//前驱结点
while (pre->next != NULL)

           {
if (pre->next->val == p->val) {
pre->next = pre->next->next;//删除结点
}

             else {
pre = pre->next;
}
}

p=p->next;
}
return head;
}
};

降一重循环，使用set去重版

class Solution {
public:
ListNode* removeDuplicateNodes(ListNode* head) {
ListNode *pre = nullptr, *cur = head;
unordered_set<int> visited;
while (cur != nullptr) {
if (visited.count(cur->val))

           {
pre->next = cur->next;
}
else

           {
visited.emplace(cur->val);
pre = cur;
}

            cur = cur->next;
}
return head;
}
};

 

 

lc04.01

有向图 bfs

class Solution {
public:
bool findWhetherExistsPath(int n, vector<vector<int>>& graph, int start, int target) {
vector<vector<int>> g(n);
vector<bool> vis(n,false);

for(auto& e:graph)
{
g[e[0]].push_back(e[1]);

}
queue<int> q;
q.push(start);
vis[start]=true;

while(q.size())
{
auto t=q.front();
q.pop();
for(auto& a:g[t])
{
if(a==target)
return true;
if(!vis[a])
{
vis[a]=true;
q.push(a);
}
}
}
return false;
}
};

 

lc01.09

拼接后，find

tip： find 找不到时返回 string::npos，找到则返回子串起始索引

class Solution {
public:
bool isFlipedString(string s1, string s2) {
int m = s1.size(), n = s2.size();
if (m != n) return false;

s1 += s1;
// find 找不到时返回 string::npos，找到则返回子串起始索引
return s1.find(s2) != string::npos; 
}
};