学习笔记数组--12.1

最新推荐文章于 2024-11-01 15:19:21 发布
最新推荐文章于 2024-11-01 15:19:21 发布
阅读量151 收藏 1
点赞数 1
文章标签： leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cheyenne98/article/details/110438727
版权

28. 实现 strStr()

在这里插入图片描述
暴力解法O(m*n)

class Solution {
public:
    int strStr(string haystack, string needle) {
        int n=haystack.length();
        int m=needle.length();
        if(n==0&&m!=0)return -1;
        if(m==0)return 0;
        int i=0,j=0;
        while(i<n&&j<m)
        {
            if(haystack[i]==needle[j]){
                i++;
                j++;
            }
            else
            {
                i=i-j+1;
                j=0;
            }
        }
        if(j==m)return i-m;
        return -1;
        }
};

point：对于搜索不到时双指针的变换i=i-j+1; j=0;
库函数解法

class Solution {
public:
    int strStr(string haystack, string needle) {
       if(needle.empty())return 0;
       int pos=haystack.find(needle);
       return pos;
    }
};

344. 反转字符串

在这里插入图片描述

class Solution {
public:
    void reverseString(vector<char>& s) {
        int i=0,j=s.size()-1;
        while(i<j)
        {
            char tmp=s[i];
            s[i]=s[j];
            s[j]=tmp;
            i++;
            j--;
        }
    }
};

561. 数组拆分 I

在这里插入图片描述

class Solution {
public:
    int arrayPairSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        int sum=0;
        for(int i=0;i<nums.size()-1;i=i+2)
        {
            sum+=nums[i];
        }
        return sum;
    }
};

1672. 最富有客户的资产总量

在这里插入图片描述

class Solution {
public:
    int maximumWealth(vector<vector<int>>& accounts) {
        int n=accounts.size();
        int m=accounts[0].size();
        int ans=0;
        for(int i=0;i<n;i++)
        {
            int sum=0;
            for(int j=0;j<m;j++)
            {
                sum+=accounts[i][j];
            }
            ans=ans>sum?ans:sum;
        }
    return ans;
    }
};

27. 移除元素

在这里插入图片描述

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

485. 最大连续1的个数

在这里插入图片描述

class Solution {
public:
    int findMaxConsecutiveOnes(vector<int>& nums) {
        int n=nums.size();
        int l=0,ans=0;
        for(int r=0;r<n;r++)
        {
            if(nums[r]==1)l=r;
            while(l<n&&nums[l]==1)
            {
                l++;
            }
            ans=(l-r)>ans?(l-r):ans;
        }         
        return ans;
    }
};

209. 长度最小的子数组

在这里插入图片描述

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n=nums.size();
        int len=n;
        for(int i=0;i<n;i++)
        {
            int j=i;
            int sum=0;
            while(sum<s&&j<n){
                sum+=nums[j];
                j++;               
            }
            if(sum>=s)len=len<(j-i)?len:(j-i);
            if(sum<s&&j-i>=n) return 0;         
        }
    return len;
    }
};

// if(sum<s&&j-i>=n) return 0;         

return len==n+1?0:len;

1512. 好数对的数目

在这里插入图片描述

class Solution {
public:
    int numIdenticalPairs(vector<int>& nums) {
        int n=nums.size();
        int count=0;
        for(int i=0;i<n;i++)
        {
            for(int j=i+1;j<n;j++)
            {
                if(nums[i]==nums[j])count++;
            }
        }
    return count;
    }
};

118. 杨辉三角

在这里插入图片描述

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> ans(numRows);
        for(int i=0;i<numRows;i++)
        {
            ans[i].resize(i + 1);
            for(int j=0;j<=i;j++)
            {
                if(i==j||j==0)ans[i][j]=1;
                else
                {
                    ans[i][j]=ans[i-1][j-1]+ans[i-1][j];
                }             
             }           
        }
        return ans;
    }
};

point: resize

119. 杨辉三角 II

在这里插入图片描述

class Solution {
public:
    vector<int> getRow(int rowIndex) {
        vector<vector<int>> tri(rowIndex+1);
        // cout<<tri[0].size()<<endl;
        for(int i=0;i<=rowIndex;i++)
        {
            tri[i].resize(i+1);
            // cout<<tri[i].size()<<endl;
            for(int j=0;j<=i;j++)
            {
                if(j==i||j==0) {
                    tri[i][j]=1;
                }
                else {
                    tri[i][j]=tri[i-1][j-1]+tri[i-1][j];
                }
            }
        }       
        return tri[rowIndex];
    }
};

class Solution {
public:
    vector<int> getRow(int rowIndex) {
        vector<int> ans(rowIndex+1);
        for(int i=0;i<=rowIndex;i++)
        {
            ans[i]=1;
            for(int j=i-1;j>0;j--)
            {
                ans[j]=ans[j]+ans[j-1];
            }
        }
    return ans;
    }
};

557. 反转字符串中的单词 III

在这里插入图片描述

class Solution {
public:
    string reverseWords(string s) {
        int n=s.length();
        int i=0,j=0;
        while(i<n&&j<n)
        {
            int j=i;
            while(s[i]!=' '&&i<n)i++;           
            myreverse(s,j,i);        
            i++;
        }
    return s;
    }
    void myreverse(string &s,int left,int right)
    {
        int l=left,r=right;
        while(l<r)
        {
            swap(s[l],s[r-1]);
            l++;
            r--;
        }
    }
};

class Solution {
public:
    string reverseWords(string s) {
        istringstream ss(s);
        string ans,str;
        while(ss>>str)
        {
            reverse(str.begin(),str.end());
            ans+=str+' ';
        }
    return ans.substr(0,ans.length()-1);
    }
};

144. 二叉树的前序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec)
    {
        if(cur==nullptr)return;
        vec.push_back(cur->val);//middle
        traversal(cur->left,vec);//left
        traversal(cur->right,vec);//right
     }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ans;
        traversal(root,ans);
        return ans;      
    }
};

94. 二叉树的中序遍历

void traversal(TreeNode* cur, vector<int>& vec)
    {
        if(cur==nullptr)return;
        traversal(cur->left,vec);//left
        vec.push_back(cur->val);//middle
        traversal(cur->right,vec);//right
     }

145. 二叉树的后序遍历

void traversal(TreeNode* cur, vector<int>& vec)
    {
        if(cur==nullptr)return;        
        traversal(cur->left,vec);//left
        traversal(cur->right,vec);//right
        vec.push_back(cur->val);//middle
     }

102. 二叉树的层序遍历

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        queue<TreeNode*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty())
        {
            vector<int> vec;
            int n=que.size();
            for(int i=0;i<n;i++)
            {
                TreeNode* node=que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
            }
            ans.push_back(vec);
        }
    return ans;
    }
};

107. 二叉树的层次遍历 II

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> ans;
        queue<TreeNode*> que;
        if(root!=NULL)que.push(root);
        while(!que.empty())
        {
            vector<int> level;
            int n=que.size();
            for(int i=0;i<n;i++)
            {
                TreeNode* node=que.front();
                que.pop();
                level.push_back(node->val);
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
            }
            ans.push_back(level);
        }
        reverse(ans.begin(),ans.end());
        return ans;
    }
};

199. 二叉树的右视图

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> ans;
        if(root!=NULL)que.push(root);
        while(!que.empty())
        {
            int n=que.size();
            for(int i=0;i<n;i++)
            {
                TreeNode*node=que.front();
                que.pop();
                if(i==n-1)ans.push_back(node->val);
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
            } 
        }
        return ans;
    }
};

637. 二叉树的层平均值

在这里插入图片描述

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> ans;
        queue<TreeNode*> que;
        if(root!=NULL)que.push(root);
        while(!que.empty())
        {
            int n=que.size();
            double sum=0;
            for(int i=0;i<n;i++)
            {
                TreeNode* node=que.front();
                que.pop();
                sum+=node->val;
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
            }
            ans.push_back(sum/n);
        }
    return ans;
    }
};

429. N 叉树的层序遍历

在这里插入图片描述

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> ans;
        queue<Node*> que;
        if(root!=NULL)que.push(root);
        while(!que.empty())
        {
            vector<int> level;
            int n=que.size();
            for(int i=0;i<n;i++)
            {
                Node* first=que.front();
                que.pop();
                level.push_back(first->val);
                for(Node* child : first->children)
                {
                    if(child)que.push(child);
                }
            }
            ans.push_back(level);
        }
        return ans;        
    }
};

515. 在每个树行中找最大值

在这里插入图片描述

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> ans;
        queue<TreeNode*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty())
        {
            int max=INT_MIN;
            int n=que.size();
            for(int i=0;i<n;i++)
            {
                TreeNode* node=que.front();
                que.pop();
                max=max>node->val?max:node->val;
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
            }
            ans.push_back(max);
        }
    return ans;        
    }
};

116、117. 填充每个节点的下一个右侧节点指针 II

在这里插入图片描述
在这里插入图片描述

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root!=NULL)que.push(root);
        while(!que.empty())
        {
            int n=que.size();
            for(int i=0;i<n;i++)
            {
                Node* first=que.front();
                que.pop();               
                Node* second=que.front();
                if(i==n-1)first->next=NULL;
                else first->next=second;
                if(first->left)que.push(first->left);
                if(first->right)que.push(first->right);
            }
        }
        return root;        
    }
};

1470. 重新排列数组

在这里插入图片描述

class Solution {
public:
    vector<int> shuffle(vector<int>& nums, int n) {
        auto ans=nums;
        int i=0,j=n;
        for(int k=0;k<2*n;k+=2)
        {
            ans[k]=nums[i];
            ans[k+1]=nums[j];
            i++;
            j++;
        }     
    return ans;
    }
};
Cheyenne98
关注
python中ans=-1_Python学习入门(1)---MIT导论
weixin_27228507的博客
03-01 1385
Python学习入门(1)---MIT导论Python学习入门(1)---MIT导论学习所用的视频和文档MIT 6.00.1xPython教程Think Pythonpython 官方文档工具[var1]使用之前需要设置格式设置->首选项->语言->勾选替换为空格[var1]官网，直接搜索安装文档centos7安装python语法[var1]1.input–输入,output–输...
微服务学习笔记1-SpringBoot
aoliaoliaoo的博客
03-30 3631
SpringBoot 1、SpringBoot简介 SpringBoot是一个javaweb的开发框架，简化开发，约定大于配置！ SpringBoot的主要优点： 让Spring开发者更快的入门 开箱即用，提供各种默认配置来简化项目配置 内嵌式容器简化Web项目 没有冗余代码生成和XML配置的要求 2、微服务简介 单体架构：打包成一个独立的单元（导入一个jar包或者是一个war包）部署完成应用之后，应用通过一个进程的方式来运行，例如，MVC三层架构 微服务架构：一个大型的复杂软件应用，由一个或者多个微
leetcode-118. 杨辉三角-生成「杨辉三角」的前 numRows 行
weixin_45794299的博客
03-24 1130
一、题目 二、思路 res[i].resize(i+1)重设元素个数 三、代码 class Solution { public: vector<vector<int>> generate(int numRows) { vector<vector<int>>res(numRows); for(int i=0;i<numRows;++i){ res[i].resize(i+1);
杨辉三角
weixin_53344209的博客
04-19 146
先来一个简单的。给一个数字，返回二维数组的杨辉三角； vector<vector> res(n);n为给定的数字； for(int i=0;i<n;i++) { res[i].resize(i+1);//给每一行确定个数； res[i][0]=1; res[i][i]=1;//第一个和最后一个都是1； for(int j=1;j<i;j++) { res[i][j]=res[i-1][j]+res[i-1][j-1]; } } return res; 再来一个进阶的。给定一个索引，输
python 2维列表定义踩坑ans=[[0] * n] * m
ledig_Vogel的博客
04-08 900
问题：leetcode刷题542题，需要定义一个二维列表m行n列，采用ans1=[[0]*n]*m，解题思路有答案始终不对。 解决：ans2= [[0] * for _ in range(m)] 原因：内存地址ans1中每一个元素是同一个内存地址，而ans2每一个元素的内存地址是不一样的：涉及到python中浅拷贝和深拷贝的概念。 ...
数据结构与算法学习笔记五--排序算法
weixin_44501366的博客
04-14 435
排序算法 1. 介绍 排序也叫排序算法（Sort Algorithm），排序是将一组数据，依指定的顺序进行排列的过程。 2. 排序的分类： 内部排序：指将需要处理的所有数据都加载到内部存储器中进行排序。 外部排序法：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。 3. 常见的排序算法分类 4. 算法的时间复杂度 度量一个程序执行时间的两种方法 事后统计的方法 这种方法可行，但是有两个问题：一是要想对设计的算法的运行性能进行评测，需要实际运行该程序；二是所得时间的统计量依赖于计算机的硬
linux应用编程和网络编程学习笔记--3.1.linux中的文件IO
人类简史
09-13 394
***********《朱有鹏老师嵌入式linux核心课程》 *********** 《3.linux应用编程和网络编程-第1部分-3.1.linux中的文件IO》 -------------------------------------------------------- 欢迎访问《朱老师物联网大讲堂》官方网站 www.zhulaoshi.org 以获取本课程更多信息 ---------------...
Nginx学习笔记3--（极客时间-陶辉）
qq_43427116的博客
04-22 617
nginx官方文档 nginx中文文档 nginx模块
Java学习笔记-个人整理的
12-19
{12.1}术语}{151}{section.12.1} {12.2}登录数据库}{151}{section.12.2} {12.3}创建表格}{152}{section.12.3} {12.4}关于null值}{154}{section.12.4} {12.5}操作符与实例}{154}{section.12.5} {12.5.1}where}{...
LEETCODE118杨辉三角Ⅰ
qq_39823579的博客
03-02 136
给定一个非负整数numRows，生成杨辉三角的前numRows行。 1. 常规写法，一行一行生成 vector<vector<int>> generate(int numRows) { vector<vector<int>> ans(numRows); //第一层vector初始化时指明大小 for(int i =0;...
MATLAB 中ans变量详细介绍
热门推荐
叮当说的博客
05-18 1万+
MATLAB 中ans变量详细介绍 ans 在MATLAB中总是显示最近的计算结果 比如：当在命令行中输入计算时，如果不将结果赋值给变量，MATLAB就会将该结果默认赋值给ans 12+12 结果：ans=24 当然如果将结果赋值给变量时，就不会出现ans这个默认变量了 比如： result=12+12 显示的结果就是 result=24 这时候就不会显示ans变量了 注意事项 在MATLAB...
LeetCode 118. 杨辉三角
RIOTSAKURA的博客
01-20 189
LeetCode 118. 杨辉三角
LEETCODE#119杨辉三角Ⅱ
qq_39823579的博客
03-02 135
给定一个非负索引k，其中 k≤33，返回杨辉三角的第 k 行。 1. 用vector实现二维数组 vector<int> getRow(int rowIndex) { vector<vector<int>> ans(rowIndex+1);//注意行数 for(int i =0;i<rowIndex+1;i++) ...
python中ans=-1_python – 字符串递归：行’返回s [0] == s [-1]和isPal(s [1：-1])’做什么？...
weixin_39947501的博客
12-10 617
我目前正在使用MITx和字符串的递归通过6.00.1x,但以下代码确实让我感到困惑.这应该告诉一个字符串是否是一个回文(一个向后读取向前),abcba作为我使用的测试字符串：def isPalindrome(s):def toChars(s):s = s.lower()ans = ''for c in s:if c in 'abcdefghijklmnopqrstuvwxyz':ans = ans...
python中ans=-1_Python中的网络扫描大杀器Scapy初探
weixin_40004212的博客
12-10 536
最近经历了Twisted的打击，这个网络编程实在看不懂，都摸不透它的内在逻辑，看来网络编程不是那么好弄的。还好，看到了scapy，这种网络的大杀器，让我一看就爱不释手，这才是我需要的网络工具啊。Scapy的功能如此之多，以至于。。。我到现在还是没看懂。在官方网站也介绍的不多，后来搜了一下，有一本书SecurityPowerTools一书中，第六章介绍了Scapy，虽然简单，但是还是不明白，这两天一...
Leetcode 62. 不同路径 动态规划+空间优化
最新发布
想买很多漂亮衣服但是买不起的博客
11-01 83
【代码】Leetcode 62. 不同路径 动态规划+空间优化。
LeetCode115：不同的子序列
Ricky_youngone的博客
10-29 246
这个是因为先判断s[i - 1]==t[i - 1]的话，第一种情况就是我们的s和t串都往前走一个单位，这个算一个，然后再加上能够符合这个条件的方案，也即是dp[i - 1][j]，这个就是t串不走了，但是s串能往前走，并且还相等的。这里就把dp[i][0] = 1;这个也需要我们去画一个2*2的方格，然后去看到这个dp[i][j]是从哪两个方向推导出来的，比如这个题，就可以从由上到下，由左到右推导出来这个公式，那么遍历顺序就直接从1开始就好。dp含义：以i-1为结尾的s中有以j-1为结尾的t的个数为。
【Python3】【力扣题】409. 最长回文串
yannan20190313的博客
11-01 198
【Python3】【力扣题】409. 最长回文串
Go语言学习笔记 - 雨痕
"Go学习笔记 By 雨痕" 这是一份由雨痕编写的Go语言学习笔记，详细记录了作者在学习Go语言过程中的心得和知识点。笔记内容涵盖Go语言的基础到高级特性，适合已经观看过无闻大神视频并希望进一步巩固和深入理解Go语言...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值