weixin_45794299的博客

一、题目二、思路三、代码class Solution {public: bool isMatch(string s, string p) { int m = s.size(); int n = p.size(); vector<vector<int>> dp(m + 1, vector<int>(n + 1)); dp[0][0] = true; for (int i

一、题目二、思路1、采用双指针方式找到两个节点2、交换两个节点的值三、代码class Solution {public: ListNode* swapNodes(ListNode* head, int k) { ListNode *fast=head; ListNode *cur=head; for(int i=0;i<k-1;++i){ cur=cur->next; }

一、题目二、思路1、双指针，快指针指向空时，慢指针指向中间节点2、慢指针新建一个头指针，方便删除下一个三、代码class Solution {public: ListNode* deleteMiddle(ListNode* head) { ListNode *fast=head; ListNode *slow=new ListNode(0); ListNode *node=slow; slow->next=head;

一、题目二、思路1、采用dfs2、传入加判断条件，比如不能超过25，传两个数时第一个数不能为0三、代码class Solution {public: int Count; int translateNum(int num) { Count=0; string str=to_string(num); int len=str.length(); dfs(str,len,0); return Count;

一、题目二、思路1、添加到哈希容器中2、遍历，找到当前数的前一个，如果不在哈希容器中，就从当前数while遍历到后面，找到长度三、代码class Solution {public: int longestConsecutive(vector<int>& nums) { unordered_set<int> dic; int size=nums.size(); for(int i=0;i<size;++

一、题目二、思路1、动态规划，在求出最长递增子序列个数的基础上，找到具体的值2、先求出长度3、找到dp[i]等于当前长度的值，添加到输出容器三、代码class Solution {public: /** * retrun the longest increasing subsequence * @param arr int整型vector the array * @return int整型vector */ vector<int&

一、题目二、思路二维动态规划dp[i][j]表示的text1的i-1和text2的j-1之间的公共子序列的长度三、代码class Solution {public: int longestCommonSubsequence(string text1, string text2) { int len1=text1.length(); int len2=text2.length(); vector<vector<int>&

一、题目二、思路1、和最长路径相似，不一定从根节点开始2、指的是这条路径上有多少个节点，再减去1三、代码class Solution {public: int ans; int diameterOfBinaryTree(TreeNode* root) { ans=1; depth(root); return ans-1; } int depth(TreeNode* root){ if(root==n

一、题目二、思路三、代码class Solution {public: vector<int> getRow(int rowIndex) { vector<vector<int>>res(rowIndex+1); for(int i=0;i<=rowIndex;++i){ res[i].resize(i+1); res[i][0]=1; res[

一、题目二、思路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);

一、题目有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品都有无限个（也就是可以放入背包多次），求解将哪些物品装入背包里物品价值总和最大。二、思路三、代码// 先遍历物品，在遍历背包void test_CompletePack() { vector<int> weight = {1, 3, 4}; vector<int> value = {15, 20, 30}; int bagWe

一、题目有N件物品和一个最多能被重量为W 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。二、思路三、代码void test_2_wei_bag_problem1() { vector<int> weight = {1, 3, 4}; vector<int> value = {15, 20, 30}; int bagWeight = 4; /

一、题目题目描述对于一个给定的链表，返回环的入口节点，如果没有环，返回null拓展：你能给出不利用额外空间的解法么？二、思路1、一个快指针、一个慢指针2、再跑第二次3、注意fast!=NULL && fast->next!=NULL，如果没有后面那个，将会报出越界的错误三、代码/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *

一、题目二、思路1、通过两个set数组去重2、判断是否在set容器里三、代码class Solution {public: vector<int> intersection(vector<int>& nums1, vector<int>& nums2) { int size1=nums1.size(); int size2=nums2.size(); set<int>dic1

一、题目二、思路三、代码class Solution {public: int search(vector<int>& arr, int target) { int size=arr.size(); int left=0,right=size-1; int mid=0; while(left<=right){ mid=(left+right)/2; /

一、题目二、思路三、代码class Solution {public: bool search(vector<int> &nums, int target) { int n = nums.size(); if (n == 0) { return false; } if (n == 1) { return nums[0] == target;

一、题目二、思路三、代码class Solution {public: int findMin(vector<int>& nums) { int low = 0; int high = nums.size() - 1; while (low < high) { int pivot = low + (high - low) / 2; if (nums[pivot]

一、题目二、思路三、代码class Solution {public: int findMin(vector<int>& nums) { int low = 0; int high = nums.size() - 1; while (low < high) { int pivot = low + (high - low) / 2; if (nums[pivot]

一、题目二、思路三、代码一class Solution {public: void rotate(vector<int>& nums, int k) { int size=nums.size(); k=k%size; reverse(nums.begin(),nums.end()); reverse(nums.begin(),nums.begin()+k); reverse(nums.be

一、题目输入多组数据，查找范围内的质数二、思路1、找到一个最大的右范围2、设置一个dp[maxnum+1]，1表示是质数，0表示非质数；初始化都为13、当一个数是1，即为质数，那么从ii开始，每加一个i都是非质数，置为0for(int j=ii;j<=right;j+=i){dp[j]=0;}4、统计dp数组，动态规划ans[i]三、代码#include <iostream>#include <string.h>#include <string&

一、题目二、思路先遍历右子节点，在中，再左，。这样就从大到小排序了。十分简单。需要注意的是k值需要提出来，不要作为参数传，因为会导致数据不同步。三、代码class Solution { int max,k; public int kthLargest(TreeNode root, int k) { this.k = k; maxValue(root); return max; } void maxValue(Tree

一、题目二、思路1、采用二叉树的中序遍历，先把所有的左子树添加进去，再开始计数到k三、代码/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {} * TreeNode(int

一、题目二、思路请你计算这个网格中共有多少个形状不同的岛屿。两个岛屿被认为是相同的，当且仅当一个岛屿可以通过平移变换（不可以旋转、翻转）和另一个岛屿重合。记录开始BFS或DFS的起点，后续点跟起点做差，存储路径到set中去重，返回 set 的大小三、代码class Solution { vector<vector<int>> dir = {{1,0},{0,1},{0,-1},{-1,0}}; int m, n; set<vector&

一、题目二、思路打印奇数层： 从左向右 打印，先左后右 加入下层节点；（根节点为奇数层）打印偶数层： 从右向左 打印，先右后左 加入下层节点；三、代码/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), righ

一、题目二、思路直接用层序遍历即可三、代码/** * 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: vecto

一、题目考虑vector每次内存扩充两倍的情况，插入n个数二、时间复杂度时间复杂度：扩容log(n)次，扩容时间复杂度2N，拷贝时间复杂度N，总的时间复杂度3N次扩充引起的元素拷贝次数为：

一、题目二、思路三、代码class Solution {public: int findKthLargest(vector<int>& nums, int k) { int size=nums.size(); priority_queue<int>Que; for(int i=0;i<size;++i){ Que.push(nums[i]); } w

一、题目二、思路1、用unordered_map容器统计个数2、将统计好的个数放入到优先队列，按个数排序3、从优先队列取出k个数到输出数组res中三、代码struct cmp{ bool operator()(pair<int,int>&a,pair<int,int>&b){ return a.first<b.first; }};class Solution {public: vector<int

auto和decltype的配合使用template<typename T, typename U>auto add(T t, U u) -> decltype(t + u) { return t + u;}

一、题目二、思路二、思路1、双指针2、右指针不等于时，左右指针同时往右移动；相等时，移动右指针三、代码class Solution {public: int removeElement(vector<int>& nums, int val) { //双指针解法 int left=0; int size=nums.size(); for(int i=0;i<size;++i){

一、题目二、思路三、代码class MyStack {public: queue<int>s,t; MyStack() { } void push(int x) { t.push(x); while(!s.empty()){ t.push(s.front()); s.pop(); } swap(s,t); }

一、题目二、思路三、代码class MyQueue {public: stack<int>s; stack<int>t; MyQueue() { } void push(int x) { while(!t.empty()){ s.push(t.top()); t.pop(); } s.push(x); }

1、单例模式（饿汉模式）#include <iostream>using namespace std;class single{private: static single* p; single(){} ~single(){}public: static single* getinstance();};single* single::p = new single();single* single::getinstance(){ return p;}int

class String{private: char *data;public: //可以充当默认构造函数 String(const char *p = nullptr) { if (p == nullptr) { data = nullptr; } else { data = new char[strlen(p) + 1];

一、strcpychar *mystrcpy(char *str1,char *str2){ if(str1==NULL || str2==NULL){ return NULL; } char *temp=str1; while(*str2!='\0'){ *str1=*str2; str1++; str2++; } *str1='\0'; return temp;}int mai

//创建套接字int serv_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);AF_INET：地址族，代表IPV4SOCK_STREAM：面向流IPPROTO_TCP：TCP协议//将套接字和IP、端口绑定 struct sockaddr_in serv_addr; //初始化结构体对象 memset(&serv_addr, 0, sizeof(serv_addr)); //为结构体对象赋值 se

#include <iostream>#include <string.h>#include <string>#include <vector>#include <map>#include <stack>#include <queue>#include <algorithm>#include <unordered_map>#include <list>#include

一、题目二、思路1、遍历一遍，ch表示字符，cht=1表示该字符的数量2、注意判断为空或者为1的情况3、注意添加最后一个字符到压缩字符串中三、代码class Solution {public: string compressString(string S) { string str=""; int len=S.length(); if(S.empty() || len==1){ return S;

一、题目二、思路思想就一句话：每次在上次能跳到的范围（end）内选择一个能跳的最远的位置（也就是能跳到max_far位置的点）作为下次的起跳点 ！三、代码class Solution {public: int jump(vector<int>& nums) { int size=nums.size(); int step=0; int end=0;// 上次跳跃可达范围右边界（下次的最右起跳点） int

一、题目二、思路dfs+回溯三、代码class Solution {public: vector<vector<int>>res; vector<int>temp; vector<vector<int>> subsets(vector<int>& nums) { int size=nums.size(); dfs(nums,0,size); re