【无标题】

力扣

根据b站up主爱学习的饲养员视频写力扣的c++代码

b站视频链接

参考博客

数组

485最大连续1 的个数

思路：用变量count 记录单次连续1的个数，用result 记录最大连续个数

class Solution {
public:
    int findMaxConsecutiveOnes(vector<int>& nums) {
        int count =0,result = 0;
        for(int i = 0;i<nums.size();i++){
            if(nums[i]==1){
                count ++;
                result = max(count,result);
            }
            else{
                count=0;
            }
        }
    result = max(count,result);
    return result;
    }
};

283移动零

思路：设置一个变量index用于记录最后一个非零元素的位置 ，利用它和后续非零元素进行交换
若index位置的元素为0,index不变，i向后寻找非零元素，找到之后与index位置的元素进行交换，index向后挪一位。
最后将最后一位非零元素之后的元素全部置零。

class Solution {
public:
	void moveZeroes(vector<int>& nums) {
		int index = 0;
        for(int i = 0;i<nums.size();i++){
            if(nums[i]!=0){
                nums[index]=nums[i];
                index ++;
            }
        }
        for(int j = index;j<nums.size();j++){
            nums[j]=0;
        }
	}
};

或者直接用swap() 进行交换就行

27移除元素

思路：利用双指针，i从第一个元素开始遍历，记录第一个等于val的元素，用j指向的不等于val的元素进行替换，j从最后一个元素向前遍历。

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        if(nums.size()==0)
            return 0;
        int i =0,j=nums.size()-1;
        while(i<j){
            while(i<j&&nums[i]!=val){
                i++;
            }
            while(i<j&&nums[j]==val){
                j--;
            }
            swap(nums[i],nums[j]);
        }
        if(nums[i]==val){
            return i;
        }
        else{
            return i+1;
        }
    }
};

这里最后要加一个if else的判断

链表

203 移除链表元素

这是一道非常简单的题目，只要知道链表是啥样的就行了，原理就是利用next去判断下一个结点是否要删除，如果要删除就将next指向再下一个元素就行了。

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        struct ListNode* dummyHead = new ListNode(0,head);
        struct ListNode* temp = dummyHead;
        while(temp!=NULL){
            if(temp->next->val == val){
                temp->next = temp->next->next;
            }
            else{
                temp=temp->next;
            }
        }
        return dummyHead->next;
    }
};

206反转链表

也是链表的基础操作之一，很多数据结构的课程都会讲到
用一个prev先去指向null 因为最后一个元素的next要指向null
cnext指向curr->next 这样改变curr->next就不会导致链表断开找不到下一个结点

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode * prev= nullptr;
        ListNode * curr = head;
        while(curr){
            ListNode* cnext = curr->next;
            curr->next = prev;
            prev = curr;
            curr = cnext;
        }
        return prev;
    }
};

这道题的递归

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == NULL || head->next == NULL) {
            return head;
        }
        ListNode* ret = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return ret;
    }
};

栈

20有效的括号

思路：如果输入字符串为空则直接返回true，遇到左括号就入栈，遇到右括号就将栈顶元素弹出判断是否匹配，最后判断栈是否为空，也是学栈这个数据结构的时候比较常见的例题了

class Solution {
public:
    bool isValid(string s) {
        if(s.size()==0)
        {
            return true;
        }
        stack<int> st;
        for(int c:s){
            if(c == '(' || c == '{' || c == '['){
                st.push(c);
            }
            else{
                if(st.size()==0){
                    return false;
                }
                else{
                    int temp = st.top();
                    st.pop();
                    if(c == ')'){
                        if(temp != '('){
                            return false;
                        }
                    }
                    if(c == '}'){
                        if(temp != '{'){
                            return false;
                        }
                    }
                    if(c == ']'){
                        if(temp != '['){
                            return false;
                        }
                    }
                }
            }
        }
        if(st.size()== 0){
            return true;
        }
        else{
             return false;
        }        
    }
};

496下一个更大元素 I

思路：利用栈先进后出的特性，能够一步步找到距离目标元素最近的那个比他大的元素，并且能够通过设置一个bool值进行分割，找到目标元素之后停止，不再继续弹出栈顶元素，即不对目标元素之前的元素再进行搜索

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) 
    {
        vector<int> result; //最后返回的结果数组
        stack<int> st1;	//将nums2 中的元素依次压入栈
        for(int i=0;i<nums2.size();i++)
        {
            st1.push(nums2[i]);
        }
        for(int j=0;j<nums1.size();j++)	//对nums1元素依次处理
        {
            stack<int> temp;	//设置一个栈用于最后将弹出的元素重新压回st1中
            bool isFound = false;	//设置一个bool值用于停止搜索
            int max=-1;	//初始化最近最大值
            while(st1.size()!=0 && !isFound)	//进行搜索，边界条件为st1中还有元素，并且没有找到nums1[j]
            {
                int top = st1.top();
                st1.pop();
                if(top > nums1[j])	//如果st1的栈顶元素比当前处理的值大那么将max值改为它
                {
                    max = top;
                }
                if(top == nums1[j]){	//如果查到了当前处理的元素相等的值，那么停止搜索
                    isFound = true;
                }
                temp.push(top);		//暂存弹出的元素
            }
            result.push_back(max);	//将得到的结果存入result中
            while(temp.size()!=0)	//将暂存元素压回st1中
            {
                st1.push(temp.top());
                temp.pop();
            }
        }
        return result;       //返回数组
    }
};

哈希表

217. 存在重复元素

思路：这是一个哈希表的基础操作，如果哈希表中不存在nums中的元素，那么就添加，值为1，如果存在就返回一个true

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_map<int,int> hash;
        if(nums.size()==0)
        {
            return false;
        }
        for(int i = 0;i<nums.size();i++)
        {
            if(hash.find(nums[i])==hash.end()){
                hash.emplace(nums[i],1);
            }
            else{
                return true;
            }
        }
        return false;
    }
};