【LeetCode-Mar-链表一】-Aet

Bingliaolong 2025-03-24 22:08 Aet | 隐藏边栏 | 抢沙发 | 6 0

文章评分 1 次，平均分 5.0 ：

LCR 023 相交链表

Question

和160题一样

Ans1

/**

* Definition for singly-linked list.

* struct ListNode {

* int val;

* ListNode *next;

* ListNode(int x) : val(x), next(NULL) {}

* };

class Solution {

public:

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {

unordered_set<ListNode*> nodes;

ListNode* tmpa = headA;

while(tmpa) {

nodes.emplace(tmpa);

tmpa = tmpa->next;

}

ListNode* tmpb = headB;

while(tmpb) {

if (nodes.count(tmpb)) {

return tmpb;

}

tmpb = tmpb->next;

}

return nullptr;

}

};

Ans2

/**

* Definition for singly-linked list.

* struct ListNode {

* int val;

* ListNode *next;

* ListNode(int x) : val(x), next(NULL) {}

* };

class Solution {

public:

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {

ListNode* a = headA;

ListNode* b = headB;

while(a != b) {

a = (a == nullptr) ? headB : a->next;

b = (b == nullptr) ? headA : b->next;

}

return a;

}

};

3263 将双链表转为数组1

Question

Ans

效率一般

/**

* Definition for doubly-linked list.

* class Node {

* int val;

* Node* prev;

* Node* next;

* Node() : val(0), next(nullptr), prev(nullptr) {}

* Node(int x) : val(x), next(nullptr), prev(nullptr) {}

* Node(int x, Node *prev, Node *next) : val(x), next(next), prev(prev) {}

* };

class Solution {

public:

vector<int> toArray(Node *head){

std::vector<int> res;

while(head) {

res.emplace_back(head->val);

head = head->next;

}

return res;

}

};

3063 链表频率

Question

Ans1

我的版本，使用map来完成，效率一般

/**

* 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* frequenciesOfElements(ListNode* head) {

std::map<int,int> data;

while(head) {

data[head->val]++;

head = head->next;

}

ListNode node(0);

ListNode* cur = &node;

for (auto item : data) {

cur->next = new ListNode(item.second);

cur = cur->next;

}

return node.next;

}

};

Ans2

优化ans1，明显缩短了执行时间

/**

* 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* frequenciesOfElements(ListNode* head) {

unordered_map<int, int> data;

vector<int> keys;

while(head) {

if (data.find(head->val) == data.end()) {

keys.push_back(head->val);

}

data[head->val]++;

head = head->next;

}

std::sort(keys.begin(), keys.end());

ListNode dmp(0);

ListNode* cur = &dmp;

for (const auto& item : keys) {

cur->next = new ListNode(data[item]);

cur = cur->next;

}

return dmp.next;

}

};

3062 链表游戏的获胜者

Question

Ans

/**

* 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:

string gameResult(ListNode* head) {

int odd = 0;

int even = 0;

while(head) {

if (head->val < head->next->val) {

odd++;

} else {

even++;

}

head = head->next->next;

}

return (odd > even) ? "Odd" : (odd == even) ? "Tie" : "Even";

}

};

1474 删除链表`M`个节点之后的`N`个节点

Question

Ans1

我的方法，循环处理，达到效果

/**

* 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* deleteNodes(ListNode* head, int m, int n) {

int count = 0;

ListNode* tmp = head;

while(tmp) {

if (count == m-1) {

ListNode* goal = tmp->next;

if (!goal) {

break;

}

int tmpn = n;

while(goal && (tmpn != 0)) {

tmpn--;

goal = goal->next;

}

if (!goal) {

tmp->next = goal;

break;

}

tmp->next = goal;

tmp = tmp->next;

count = 0;

continue;

}

count++;

tmp = tmp->next;

}

return head;

}

};

Ans2

ans1的代码优化版本，逻辑是一样的

/**

* 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* deleteNodes(ListNode* head, int m, int n) {

ListNode* cur = head;

ListNode* last = head;

while(cur) {

int mm = m, nn = n;

while (cur && (mm != 0)) {

last = cur;

cur = cur->next;

mm--;

}

while(cur && (nn != 0)) {

cur = cur->next;

nn--;

}

last->next = cur;

}

return head;

}

};

1290 二进制链表转整数

Question

Ans1

先反转链表，然后从低位开始不断计算

/**

* 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) {}

* };

#include <cmath>

class Solution {

public:

int getDecimalValue(ListNode* head) {

ListNode* prev = nullptr;

ListNode* cur = head;

ListNode* next = nullptr;

while(cur) {

next = cur->next;

cur->next = prev;

prev = cur;

cur = next;

}

int count = 0;

int sum = 0;

while(prev) {

sum += prev->val * pow(2, count);

count++;

prev = prev->next;

}

return sum;

}

};

Ans2

构建res的二进制位，每次循环先左移一位，确保末尾是0，让这个0去和下一位去或运算

/**

* 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:

int getDecimalValue(ListNode* head) {

int res = 0;

while(head) {

res <<= 1;

res |= head->val;

head = head->next;

}

return res;

}

};

Ans3

原理和ans2一样

/**

* 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:

int getDecimalValue(ListNode* head) {

int res = 0;

while(head) {

res = res*2 + head->val;

head = head->next;

}

return res;

}

};

876 链表的中间节点

Question

Ans1

我的方法，快慢指针

/**

* 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* middleNode(ListNode* head) {

ListNode* slow = head;

ListNode* fast = head;

while(slow && fast && fast->next) {

slow = slow->next;

if (fast->next) {

fast = fast->next->next;

} else {

break;

}

return slow;

}

};

Ans2

用vector去保存head，只要head有指向一个节点，就不断把下一个节点添加到vector里面

/**

* 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* middleNode(ListNode* head) {

std::vector<ListNode*> vec {head};

while (vec.back()->next) {

vec.push_back(vec.back()->next);

}

return vec.at(vec.size()/2);

}

};

Ans3

单指针遍历出链表长度，计算出中间节点
似乎性能不如快慢指针

/**

* 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* middleNode(ListNode* head) {

int count = 0;

ListNode* tmp = head;

while(tmp) {

count++;

tmp = tmp->next;

}

tmp = head;

int sz = 0;

while(tmp) {

sz++;

if (sz == (count/2+1)) {

return tmp;

}

tmp = tmp->next;

}

return tmp;

}

};

706 设计哈希映射

Question

Ans1

性能不好

class MyHashMap {

std::vector<std::pair<int, int>> data;

public:

MyHashMap() {

}

void put(int key, int value) {

for (auto& item : data) {

if (item.first == key) {

item.second = value;

return;

}

data.emplace_back(key, value);

}

int get(int key) {

for (auto & item : data) {

if (item.first == key) {

return item.second;

}

return -1;

}

void remove(int key) {

using iter = std::vector<std::pair<int, int>>::iterator;

for (iter ite = data.begin(); ite != data.end(); ) {

if ((*ite).first == key) {

data.erase(ite);

} else {

ite++;

}

};

/**

* Your MyHashMap object will be instantiated and called as such:

* MyHashMap* obj = new MyHashMap();

* obj->put(key,value);

* int param_2 = obj->get(key);

* obj->remove(key);

Ans2

好了一些

class MyHashMap {

private:

vector<list<pair<int,int>>> data;

static const int base = 789;

int hash(int key) {

return key % 789;

}

public:

MyHashMap() : data(base) {

}

void put(int key, int value) {

int h = hash(key);

for (auto ite = data[h].begin(); ite != data[h].end(); ite++) {

if (ite->first == key) {

ite->second = value;

return;

}

data[h].push_back(make_pair(key, value));

}

int get(int key) {

int h = hash(key);

for (auto ite = data[h].begin(); ite != data[h].end(); ite++) {

if (ite->first == key) {

return ite->second;

}

return -1;

}

void remove(int key) {

int h = hash(key);

for (auto ite = data[h].begin(); ite != data[h].end(); ite++) {

if (ite->first == key) {

data[h].erase(ite);

return;

}

};

/**

* Your MyHashMap object will be instantiated and called as such:

* MyHashMap* obj = new MyHashMap();

* obj->put(key,value);

* int param_2 = obj->get(key);

* obj->remove(key);

705 设计哈希集合

Question

Ans1

通过了，但是性能很差

class MyHashSet {

private:

std::list<int> map;

std::list<int>::iterator find_key(int key) {

auto ite = map.begin();

while(ite != map.end()) {

if (*ite == key) {

return ite;

}

ite++;

}

return map.end();

}

public:

MyHashSet() {

}

void add(int key) {

if (!contains(key)) {

map.push_back(key);

}

void remove(int key) {

auto ite = find_key(key);

if (ite != map.end()) {

map.remove(key);

}

bool contains(int key) {

return find_key(key) != map.end();

}

};

/**

* Your MyHashSet object will be instantiated and called as such:

* MyHashSet* obj = new MyHashSet();

* obj->add(key);

* obj->remove(key);

* bool param_3 = obj->contains(key);

Ans2

class MyHashSet {

vector<list<int>> bukets;

static const int base = 789;

int hash(int key) {

return key % 789;

}

std::list<int>::iterator find_key(std::list<int>& lst, int key) {

for (std::list<int>::iterator ite = lst.begin(); ite != lst.end(); ite++) {

if (*ite == key) {

return ite;

}

return lst.end();

}

std::list<int>& get_list(int key) {

auto hs = hash(key);

return bukets[hs];

}

public:

MyHashSet() : bukets(base) {

}

void add(int key) {

int h = hash(key);

for (auto ite = bukets[h].begin(); ite != bukets[h].end(); ite++) {

if (*ite == key) {

return;

}

bukets[h].push_back(key);

}

void remove(int key) {

int h = hash(key);

for (auto ite = bukets[h].begin(); ite != bukets[h].end(); ite++) {

if (*ite == key) {

bukets[h].erase(ite);

return;

}

bool contains(int key) {

int h = hash(key);

for (auto ite = bukets[h].begin(); ite != bukets[h].end(); ite++) {

if (*ite == key) {

return true;

}

return false;

}

};

/**

* Your MyHashSet object will be instantiated and called as such:

* MyHashSet* obj = new MyHashSet();

* obj->add(key);

* obj->remove(key);

* bool param_3 = obj->contains(key);

2255 统计是给定字符串前缀的字符串数目

Question

Ans1

class Solution {

public:

int countPrefixes(vector<string>& words, string s) {

int count = 0;

for (auto & item : words) {

if(item.size() > s.size()) {

continue;

}

if (s.compare(0, item.size(), item) == 0) {

count++;

}

return count;

}

};

21 合并两个有序链表

Question

Ans

/**

* 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* mergeTwoLists(ListNode* list1, ListNode* list2) {

ListNode tmp(0);

ListNode* tail = &tmp;

while (list1 && list2) {

if (list1->val < list2->val) {

tail->next = list1;

list1 = list1->next;

} else {

tail->next = list2;

list2 = list2->next;

}

tail = tail->next;

}

tail->next = list1 ? list1 : list2;

return tmp.next;

}

};

83 删除排序链表中的重复元素

Question

Ans1

/**

* 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* deleteDuplicates(ListNode* head) {

if (!head) {

return nullptr;

}

if (!head->next) {

return head;

}

ListNode* tmp = head;

head = head->next;

tmp->next = nullptr;

ListNode* tail = tmp;

int tmp_val = tmp->val;

while(head) {

if (head->val != tmp_val) {

ListNode* tmp1 = head->next;

head->next = tail->next;

tail->next = head;

tmp_val = head->val;

tail = tail->next;

head = tmp1;

} else {

head = head->next;

}

return tmp;

}

};

Ans2

/**

* 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* deleteDuplicates(ListNode* head) {

if (!head) {

return head;

}

ListNode* cur = head;

while(cur->next) {

if (cur->next->val == cur->val) {

cur->next = cur->next->next;

} else {

cur = cur->next;

}

return head;

}

};

141 环形链表

Question

Ans1

快慢指针

/**

* Definition for singly-linked list.

* struct ListNode {

* int val;

* ListNode *next;

* ListNode(int x) : val(x), next(NULL) {}

* };

class Solution {

public:

bool hasCycle(ListNode *head) {

if (!head || !head->next) {

return false;

}

ListNode* slow = head;

ListNode* fast = head;

while(fast && fast->next) {

slow = slow->next;

fast = fast->next->next;

if (slow == fast) {

return true;

}

return false;

}

};

Ans2

用了std::unordered_set统计结点出现的次数

/**

* Definition for singly-linked list.

* struct ListNode {

* int val;

* ListNode *next;

* ListNode(int x) : val(x), next(NULL) {}

* };

class Solution {

public:

bool hasCycle(ListNode *head) {

std::unordered_set<ListNode*> nodes;

while(head) {

if(nodes.count(head)) {

return true;

}

nodes.emplace(head);

head = head->next;

}

return false;

}

};

160 相交链表

Question

Ans1

效率较差

/**

* Definition for singly-linked list.

* struct ListNode {

* int val;

* ListNode *next;

* ListNode(int x) : val(x), next(NULL) {}

* };

class Solution {

public:

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {

ListNode* tmpa = headA;

ListNode* tmpb = headB;

while(tmpa) {

while(tmpb) {

if (tmpa == tmpb) {

return tmpa;

}

tmpb = tmpb->next;

}

tmpb = headB;

tmpa = tmpa->next;

}

return nullptr;

}

};

Ans2

使用std::unordered_set将每个结点存一下
优化效果明显

/**

* Definition for singly-linked list.

* struct ListNode {

* int val;

* ListNode *next;

* ListNode(int x) : val(x), next(NULL) {}

* };

class Solution {

public:

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {

std::unordered_set<ListNode*> nodes;

ListNode* tmpa = headA;

while(tmpa) {

nodes.emplace(tmpa);

tmpa = tmpa->next;

}

ListNode* tmpb = headB;

while(tmpb) {

if (nodes.count(tmpb)) {

return tmpb;

}

tmpb = tmpb->next;

}

return nullptr;

}

};

Ans3

最优的方法

/**

* Definition for singly-linked list.

* struct ListNode {

* int val;

* ListNode *next;

* ListNode(int x) : val(x), next(NULL) {}

* };

class Solution {

public:

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {

ListNode* tmpa = headA;

ListNode* tmpb = headB;

while(tmpa != tmpb) {

tmpa = tmpa ? tmpa->next : headB;

tmpb = tmpb ? tmpb->next : headA;

}

return tmpa;

}

};

思路如下：
设「第一个公共节点」为 node ，「链表 headA」的节点数量为 a ，「链表 headB」的节点数量为 b ，「两链表的公共尾部」的节点数量为 c ，则有：
1. 头节点 headA 到 node 前，共有 a−c 个节点
2. 头节点 headB 到 node 前，共有 b−c 个节点
考虑构建两个节点指针 A , B 分别指向两链表头节点 headA , headB ，做如下操作：
1. 指针 A 先遍历完链表 headA ，再开始遍历链表 headB ，当走到 node 时，共走步数为：
2. a+(b-c)
3. 指针 B 先遍历完链表 headB ，再开始遍历链表 headA ，当走到 node 时，共走步数为：
4. b+(a-c)
按上面的思路，两个指针遍历到公共节点时，A和B重合，且走的步数相同
1. 公式上表现为：a+(b-c)=b+(a-c)
2. 则有两种情况：
3. 情况一：假如两个链表有公共尾部，也就是c大于0的情况，指针A和B会同时指向公共节点node
4. 情况二：假如两个链表无公共尾部，也即是c等于0的情况，指针A和B会同时指向nullptr

203 移除链表元素

Question

Ans1

/**

* 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* removeElements(ListNode* head, int val) {

if (!head) {

return head;

}

while(head) {

if (head->val != val) {

break;

}

head = head->next;

}

if (!head) {

return head;

}

ListNode* cur = head;

while(head->next) {

if (head->next->val == val) {

head->next = head->next->next;

} else {

head = head->next;

}

return cur;

}

};

Ans2

递归的方式

/**

* 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* removeElements(ListNode* head, int val) {

if (!head) {

return head;

}

auto res = removeElements(head->next, val);

if (head->val == val) {

return res;

} else {

head->next = res;

return head;

}

};

/**

* 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* removeElements(ListNode* head, int val) {

if (!head) {

return head;

}

head->next = removeElements(head->next, val);

return head->val == val ? head->next : head;

}

};

把任务交给下一个节点去处理，认为下一个节点总是返回正确的结果
拿到结果后，再判断一下自己是不是目标
1. 如果自己是目标，那就返回正确的结果，不返回自己，因为有自己就不正确了
2. 如果自己不是目标，那就把结果挂在自己后面，然后返回自己，因为自己加上结果，才是正确的结果

Ans3

双指针

/**

* 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* removeElements(ListNode* head, int val) {

while (head && head->val == val) {

head = head->next;

}

ListNode* cur = head;

ListNode* pre = head;

while (cur) {

if (cur->val == val) {

pre->next = cur->next;

} else {

pre = cur;

}

cur = cur->next;

}

return head;

}

};

206 反转链表

Question

Ans1

/**

* 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* reverseList(ListNode* head) {

if (!head) {

return head;

}

ListNode* prev = nullptr;

ListNode* cur = head;

ListNode* next = nullptr;

while(cur) {

next = cur->next;

cur->next = prev;

prev = cur;

cur = next;

}

return prev;

}

};

Ans2

递归的方式

/**

* 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* reverseList(ListNode* head) {

if (!head || !head->next) {

return head;

}

ListNode* cur = reverseList(head->next);

head->next->next = head;

head->next = nullptr;

return cur;

}

};

234 回文链表

Question

Ans

/**

* 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:

bool isPalindrome(ListNode* head) {

if (!head) {

return false;

}

if (!head->next) {

return true;

}

ListNode* slow = head;

ListNode* fast = head;

while (slow && fast) {

slow = slow->next;

if (fast->next) {

fast = fast->next->next;

} else {

break;

}

ListNode*prev = nullptr;

ListNode* cur = slow;

ListNode* next = nullptr;

while(cur) {

next = cur->next;

cur->next = prev;

prev = cur;

cur = next;

}

while(prev) {

if (head->val != prev->val) {

return false;

}

head = head->next;

prev = prev->next;

}

return true;

}

};

LCR 023 相交链表
Question
Ans1
Ans2
3263 将双链表转为数组1
Question
Ans
3063 链表频率
Question
Ans1
Ans2
3062 链表游戏的获胜者
Question
Ans
1474 删除链表M个节点之后的N个节点
Question
Ans1
Ans2
1290 二进制链表转整数
Question
Ans1
Ans2
Ans3
876 链表的中间节点
Question
Ans1
Ans2
Ans3
706 设计哈希映射
Question
Ans1
Ans2
705 设计哈希集合
Question
Ans1
Ans2
2255 统计是给定字符串前缀的字符串数目
Question
Ans1
21 合并两个有序链表
Question
Ans
83 删除排序链表中的重复元素
Question
Ans1
Ans2
141 环形链表
Question
Ans1
Ans2
160 相交链表
Question
Ans1
Ans2
Ans3
203 移除链表元素
Question
Ans1
Ans2
Ans3
206 反转链表
Question
Ans1
Ans2
234 回文链表
Question
Ans

本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！

Bingliaolong 关注：0 粉丝：0 最后编辑于：2025-04-02

Everything will be better.

一	二	三	四	五	六	日
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31

【LeetCode-Mar-链表一】

LCR 023 相交链表

Question

Ans1

Ans2

3263 将双链表转为数组1

Question

Ans

3063 链表频率

Question

Ans1

Ans2

3062 链表游戏的获胜者

Question

Ans

1474 删除链表M个节点之后的N个节点

Question

Ans1

Ans2

1290 二进制链表转整数

Question

Ans1

Ans2

Ans3

876 链表的中间节点

Question

Ans1

Ans2

Ans3

706 设计哈希映射

Question

Ans1

Ans2

705 设计哈希集合

Question

Ans1

Ans2

2255 统计是给定字符串前缀的字符串数目

Question

Ans1

21 合并两个有序链表

Question

Ans

83 删除排序链表中的重复元素

Question

Ans1

Ans2

141 环形链表

Question

Ans1

Ans2

160 相交链表

Question

Ans1

Ans2

Ans3

203 移除链表元素

Question

Ans1

Ans2

Ans3

206 反转链表

Question

Ans1

Ans2

234 回文链表

Question

Ans

你可能也喜欢

热评文章

发表评论

标签云集

1474 删除链表`M`个节点之后的`N`个节点