Leetcode基础刷题记录（顺序式容器）（C++）

知识结构和配套习题都来自于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;
        }
};