随着计算机技术的发展,越来越多的计算任务需要通过算法来完成。其中,LeetCode算法题是程序员们不断挑战自我的一个平台。在这些题目中,容器成为了一个非常重要的工具。本文将介绍在LeetCode算法题中如何使用容器完成复杂的计算任务,并通过演示代码来展示实现过程。
一、LeetCode算法题中的容器
在LeetCode算法题中,容器是一个非常重要的工具。我们可以使用各种容器来完成不同的计算任务。常见的容器包括数组、链表、栈、队列、堆、哈希表、二叉树等等。
二、使用容器完成复杂的计算任务
- 数组
数组是一种非常基础的容器。在LeetCode算法题中,我们经常需要使用数组来存储数据,并通过数组来完成各种计算任务。例如,我们可以使用数组来实现冒泡排序、快速排序、二分查找等算法。
以下是一个使用数组实现冒泡排序的示例代码:
void bubbleSort(int arr[], int n)
{
for (int i = 0; i < n - 1; i++)
for (int j = 0; j < n - i - 1; j++)
if (arr[j] > arr[j + 1])
swap(arr[j], arr[j + 1]);
}
- 链表
链表是一种非常常见的容器。在LeetCode算法题中,我们经常需要使用链表来存储数据,并通过链表来完成各种计算任务。例如,我们可以使用链表来实现反转链表、删除链表中的重复元素、合并两个有序链表等算法。
以下是一个使用链表实现反转链表的示例代码:
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* prev = nullptr;
ListNode* curr = head;
while (curr != nullptr) {
ListNode* nextTemp = curr->next;
curr->next = prev;
prev = curr;
curr = nextTemp;
}
return prev;
}
};
- 栈
栈是一种非常有用的容器。在LeetCode算法题中,我们经常需要使用栈来存储数据,并通过栈来完成各种计算任务。例如,我们可以使用栈来实现括号匹配、计算逆波兰表达式等算法。
以下是一个使用栈实现括号匹配的示例代码:
class Solution {
public:
bool isValid(string s) {
stack<char> stk;
for (char c : s) {
if (c == "(" || c == "[" || c == "{") {
stk.push(c);
} else {
if (stk.empty()) {
return false;
}
char topc = stk.top();
stk.pop();
if ((c == ")" && topc != "(") ||
(c == "]" && topc != "[") ||
(c == "}" && topc != "{")) {
return false;
}
}
}
return stk.empty();
}
};
- 队列
队列是一种非常常见的容器。在LeetCode算法题中,我们经常需要使用队列来存储数据,并通过队列来完成各种计算任务。例如,我们可以使用队列来实现广度优先搜索、队列实现栈等算法。
以下是一个使用队列实现广度优先搜索的示例代码:
class Solution {
public:
int openLock(vector<string>& deadends, string target) {
unordered_set<string> deads(deadends.begin(), deadends.end());
unordered_set<string> visited;
queue<string> q{{"0000"}};
int step = 0;
while (!q.empty()) {
int size = q.size();
for (int i = 0; i < size; ++i) {
string t = q.front();
q.pop();
if (deads.count(t)) continue;
if (t == target) return step;
for (int j = 0; j < 4; ++j) {
string up = plusOne(t, j);
if (!visited.count(up)) {
q.push(up);
visited.insert(up);
}
string down = minusOne(t, j);
if (!visited.count(down)) {
q.push(down);
visited.insert(down);
}
}
}
++step;
}
return -1;
}
};
- 堆
堆是一种非常有用的容器。在LeetCode算法题中,我们经常需要使用堆来存储数据,并通过堆来完成各种计算任务。例如,我们可以使用堆来实现TopK问题、堆排序等算法。
以下是一个使用堆实现TopK问题的示例代码:
class Solution {
public:
vector<int> topKFrequent(vector<int>& nums, int k) {
unordered_map<int, int> freq;
for (int num : nums) {
++freq[num];
}
priority_queue<pair<int, int>> pq;
for (auto p : freq) {
pq.push({p.second, p.first});
if (pq.size() > k) {
pq.pop();
}
}
vector<int> res;
while (!pq.empty()) {
res.push_back(pq.top().second);
pq.pop();
}
reverse(res.begin(), res.end());
return res;
}
};
- 哈希表
哈希表是一种非常常见的容器。在LeetCode算法题中,我们经常需要使用哈希表来存储数据,并通过哈希表来完成各种计算任务。例如,我们可以使用哈希表来实现两数之和、字母异位词分组等算法。
以下是一个使用哈希表实现两数之和的示例代码:
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 t = target - nums[i];
if (hash.count(t)) {
return {hash[t], i};
}
hash[nums[i]] = i;
}
return {};
}
};
- 二叉树
二叉树是一种非常有用的容器。在LeetCode算法题中,我们经常需要使用二叉树来存储数据,并通过二叉树来完成各种计算任务。例如,我们可以使用二叉树来实现二叉树的遍历、二叉树的最大深度等算法。
以下是一个使用二叉树实现二叉树的遍历的示例代码:
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> res;
stack<TreeNode*> stk;
while (root != nullptr || !stk.empty()) {
while (root != nullptr) {
stk.push(root);
root = root->left;
}
root = stk.top();
stk.pop();
res.push_back(root->val);
root = root->right;
}
return res;
}
};
三、总结
在LeetCode算法题中,容器是一个非常重要的工具。我们可以使用各种容器来完成不同的计算任务。常见的容器包括数组、链表、栈、队列、堆、哈希表、二叉树等等。通过使用容器,我们可以更加便捷地完成各种复杂的计算任务。