知识结构和配套习题都来自于b站up主:爱学习的饲养员。
1.数组
在连续的内存空间中,存储一组相同类型的元素。
区分元素和索引(索引是相对第一个元素的距离)。
访问元素 | 搜索元素 | 添加元素 | 删除元素 |
---|---|---|---|
O(1) | O(1) | O(N) | O(N) |
在C++容器库中 vector,能存放任意类型的动态数组
不是在原空间之后续接新空间,而是找更大的内存空间,将原数据拷贝到新空间,释放原空间
swap()交换vector对象,可以动态压缩数组空间
reserve()预留空间
例题:
- 283 移动零
- 27 移除元素
class Solution {
public:
void moveZeroes(vector<int>& nums) {
int temp = 0;
int length = nums.size();
for (vector<int>::iterator it = nums.begin(); it != nums.end(); )
{
if(temp==nums.size())
{
break;
}
else {
if (*it == 0)
{
it = nums.erase(it); //使用erase时,迭代器的越界问题
//即原有迭代器it失效,所以要用一个新的it接收erase()的返回值
nums.push_back(0);
}
else
{
it++;
}
temp++;
}
}
}
};
class Solution { //双指针法
public:
int removeElement(vector<int>& nums, int val) {
if (nums.size() == 0 || nums.empty()) return 0;
int left = 0, right = nums.size() - 1;
while (left < right) {
while (left < right && nums[left] != val) left++;
while (left < right && nums[right] == val) right--;
swap(nums[left], nums[right]);
}
if (nums[left] == val) return left;
else return left + 1;
}
};
2.链表
存储在离散的内存空间中。
优点:1.链表执行插入和删除操作方便,修改指针即可。
2.采用动态存储分配,不会造成内存浪费和溢出
缺点:空间(指针域)和时间(遍历)耗费较大
访问元素 | 搜索元素 | 添加元素 | 删除元素 |
---|---|---|---|
O(N) | O(N) | O(1) | O(1) |
list容器,迭代器不支持随机访问
–> 插入和删除不会造成原有迭代器失效
–> at()和中括号[]访问的方式都失效
–> 所有不支持随机迭代器的容器,不可以用标准算法(algorithm),但内部会提供一些对应的算法
例题:
- 203 移除链表元素
- 206 反转单链表
class Solution {
public:
ListNode* removeElements(ListNode* head, int val) {
ListNode* sentinel = new ListNode(); //哨兵记录操作链表的头部,val赋值为0
sentinel->next = head;
ListNode *prev = sentinel, *curr = head, *toDelete = nullptr; //链表操作中常常需要记录上一个和下一个的信息
while (curr != nullptr) {
if (curr->val == val) {
prev->next = curr->next;
toDelete = curr;
} else prev = curr;
curr = curr->next;
if (toDelete != nullptr) {
delete toDelete;
toDelete = nullptr;
}
}
ListNode *ret = sentinel->next;
delete sentinel;
return ret;
}
};
// 迭代实现
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* curr = head;
ListNode* prev = nullptr;
while (curr != NULL) {
ListNode* back=curr->next;
curr->next=prev;
prev=curr;
curr=back;
}
delete curr;//单链表其实不需要
return prev;
}
};
class Solution {
public:
ListNode* reverseList(ListNode* head) {
if(head == NULL || head->next == NULL){
return head;
}
ListNode* p=reverseList(head->next);
head->next->next=head;
head->next=NULL;
return p;
}
};
3.队列
先进先出,队尾进,队首出。
只有队首和队首可以访问
访问元素 | 搜索元素 | 添加元素 | 删除元素 |
---|---|---|---|
O(N) | O(N) | O(1) | O(1) |
queue 队列容器
同样没有 at() 和 [ ] 方法访问,使用 front()和back()
push()和pop()不加上 _back 了
例题:
- 933 最近请求次数
class RecentCounter {
public:
queue<int> que;
RecentCounter() { } // 构造函数
int ping(int t) {
que.push(t);
while(que.back()-que.front()>3000)
{
que.pop();
}
return que.size();
}
};
4.栈
先进后出,队尾进,队首出。
访问元素 | 搜索元素 | 添加元素 | 删除元素 |
---|---|---|---|
O(1) | O(N) | O(1) | O(1) |
例题:
- 20 有效的括号
- 496 下一个更大的元素Ⅰ
思路:由于后遇到的左括号要先闭合,因此我们可以将这个左括号放入栈中,碰到右括号则出栈,完全符合栈的特性。
class Solution {
public:
bool isValid(string s) {
if(s.empty())
{return true;}
stack<char> stk;
unordered_map<char,char> map={
{')','('},{']','['},{'}','{'}
};
char temp;
for(char ch:s){
if(!map.count(ch)){
stk.push(ch);
}
else{
if(stk.empty() || stk.top()!=map[ch]){
return false;
}
stk.pop();
}
}
if(stk.size()==0)
{return true;}
else{
return false;
}
}
};
思路:单调栈解决下一个更大元素(nextGreater)问题。
单调栈实际上就是栈,只是利用了一些巧妙的逻辑,使得每次新元素入栈后,栈内的元素都保持有序(单调递增或单调递减)。
针对本题,由于nums1是nums2的子集,所以可以先针对nums2中每个数据,找到它之后第一个比它大的元素,对应关系存储到哈希表中。这样遍历nums1,在哈希表中查找就可以了。
class Solution {
public:
vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
vector<int> ret;
stack<int> stk;
unordered_map<int,int> map;
int a=nums1.size();
for(int i=0;i<nums2.size();i++) //遍历nums2数组,找到每个数右边比它大的第一个数
{ while(!stk.empty() && nums2[i]>stk.top()){ //如果栈不为空,并且当前值较大
map.insert({stk.top(),nums2[i]}); // 栈顶(key)-> 当前值(value)
stk.pop(); // 栈顶的nextGreater已找到,出栈
}
stk.push(nums2[i]);
}
while(!stk.empty()){
map.insert({stk.top(),-1});
stk.pop();
}
for(int j=0;j<a;j++){
ret.push_back(map[nums1[j]]);
}
return ret;
}
};