#1.两数之和
暴力求解：时间复杂度O(n^2) 空间复杂度O(1)
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
vector<int> result;
for(int i=0;i<nums.size();i++){
for(int j=i+1;j<nums.size();j++){
if(nums[i]+nums[j]==target){
result.push_back(i);
result.push_back(j);
return result;
}
}
}
return result;
}
};一遍哈希表法：时间复杂度O(n) 空间复杂度O(n)
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> myhash;
vector<int> out;
/* 首先所有的数据哈希映射表 */
for (int i = 0; i < nums.size(); i++) {
myhash[nums[i]] = 1;
}
for (int i = 0; i < nums.size(); i++) {
/* 在这里 判断 如果 存在 target - nums[i] 对应的 值 并且这个值不是自己 */
/*映射关系 key->value, key:target - nums[i], value:myhash[target - nums[i]]*/
if (myhash[target - nums[i]] && (myhash[target - nums[i]] != i)) {
out.push_back(i);
out.push_back(myhash[target - nums[i]]);
return out;
}
}
return out;
}
};
#2.两数相加
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode result(-1);
int flag=0;
ListNode *p=&result;
while(l1!=NULL || l2!=NULL){
int temp=l1?l1->val:0;
temp+=l2?l2->val:0;
temp+=flag;
if(temp>=10){
flag=1;
temp=temp-10;
}
else{
flag=0;
temp=temp;
}
p->next=new ListNode(temp);
p=p->next;
if(l1) l1=l1->next;
if(l2) l2=l2->next;
}
if(flag){
p->next=new ListNode(1);
}
return result.next;
}
};#3.无重复字符的最长字串
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
class Solution {
public:
int lengthOfLongestSubstring(string s) {
//窗口头指针
int begin=0;
int result=0;
std::string word="";
//字符哈希
int char_map[128]={0};
for(int i=0;i<s.length();i++){
char_map[s[i]]++;
if(char_map[s[i]]==1){//没出现过
word+=s[i];
if(result<word.length()){
result=word.length();
}
}
else{//将重复的字符s[i]去掉
while(begin<i && char_map[s[i]]>1){
char_map[s[begin]]--;
begin++;
}
word="";
for(int j=begin;j<=i;j++){
word+=s[j];
}
}
}
return result;
}
};#5.最长回文串
class Solution {
public:
string longestPalindrome(string s) {
int n = s.size();
vector<vector<int>> dp(n, vector<int>(n));
string ans;
for (int l = 0; l < n; ++l) {
for (int i = 0; i + l < n; ++i) {
int j = i + l;
if (l == 0) {
dp[i][j] = 1;
}
else if (l == 1) {
dp[i][j] = (s[i] == s[j]);
}
else {
dp[i][j] = (s[i] == s[j] && dp[i + 1][j - 1]);
}
if (dp[i][j] && l + 1 > ans.size()) {
ans = s.substr(i, l + 1);
}
}
}
return ans;
}
};
#7.整数反转
class Solution {
public:
int reverse(int x) {
long long ans=0;
const int maxInt=0x7FFFFFFF;
const int minInt=0x80000000;
while(x!=0){
ans=ans*10+x%10;
x=x/10;
}
if(ans>maxInt || ans<minInt){
return 0;
}
return ans;
}
};#8.字符串转换整数（atoi）
class Solution {
public:
int myAtoi(string str) {
bool flag=true;
long long ans=0;
const int maxInt=0x7FFFFFFF;
const int minInt=0x80000000;
const long long MAX = 0x100000000;
int cur=0;
//空格
while(cur<str.length() && str[cur]==' '){
cur++;
}
//符号
if(cur<str.length() && str[cur]=='+'){
flag=true;
cur++;
}
else if(str[cur]=='-' && cur<str.length()){
flag=false;
cur++;
}
//求数
for(;cur<str.length();cur++){
if(str[cur]>='0' && str[cur]<='9'){
ans=ans*10+(str[cur]-'0');
if(ans > MAX){
ans=MAX;
break;
}
}
else{
break;
}
}
if(!flag){
ans=-ans;
}
if(ans>maxInt){
return maxInt;
}
else if(ans<minInt){
return minInt;
}
return ans;
}
};#11.盛最多水的容器
class Solution {
public:
int maxArea(vector<int>& height) {
if(height.size()==0){
return 0;
}
if(height.size()==1){
return height[0];
}
int left=0;
int right=height.size()-1;
int result=0;
while(left<right){
//短的值*区间长度
int temp=(right-left)*(height[left]<height[right]?height[left]:height[right]);
if(temp>result){
result=temp;
}
if(height[left]<height[right]){
left++;
}
else{
right--;
}
}
return result;
}
};#13.罗马数字转整数
class Solution {
public:
int romanToInt(string s) {
int result=0;
map<char,int> luomab={
{'I',1},
{'V',5},
{'X',10},
{'L',50},
{'C',100},
{'D', 500},
{'M', 1000}
};//初始化哈希表
for(int i=0;i<s.length();i++)
{
if(luomab[s[i]] < luomab[s[i+1]])
result -= luomab[s[i]];
else
{
result += luomab[s[i]];
}
}
return result;
}
};
#14.最长公共前缀
class Solution {
public:
string longestCommonPrefix(vector<string>& strs) {
if(strs.size()==0){
return "";
}
for(int i=0;i<strs[0].size();i++){
char temp=strs[0][i];
for(int j=0;j<strs.size();j++){
if(strs[j].size()==i ||strs[j][i]!=temp){
return strs[0].substr(0,i);
}
}
}
return strs[0];
}
};
#15.三数之和
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
int n=nums.size();
sort(nums.begin(),nums.end());
vector<vector<int>> ans;
for(int first=0;first<n;first++){
if(first>0&&nums[first]==nums[first-1]){
continue;
}
int second=first+1;
int third=n-1;
int target=-nums[first];
for(;second<third;second++){
if(second>first+1 && nums[second]==nums[second-1]){
continue;
}
while(second<third&& nums[second]+nums[third]>target){
third--;
}
if(second==third){
break;
}
if(nums[second]+nums[third]==target){
ans.push_back({nums[first],nums[second],nums[third]});
}
}
}
return ans;
}
};
#17.电话号码的字母组合
DFS解决
class Solution {
public:
map<char,string> hashmap={
{'2',"abc"},{'3',"def"},{'4',"ghi"},
{'5',"jkl"},{'6',"mno"},{'7',"pqrs"},
{'8',"tuv"},{'9',"wxyz"}
};
void DFS(int index,string digits,vector<string>&results,string &str){
if(index==digits.size()){
results.push_back(str);
}
for(int i=0;i<hashmap[digits[index]].size();i++){
str+=hashmap[digits[index]][i];
DFS(index+1,digits,results,str);
str.pop_back();
}
}
vector<string> letterCombinations(string digits) {
vector<string> results;
string str;
if(digits.size()==0){
return results;
}
DFS(0,digits,results,str);
return results;
}
};#19.删除链表的倒数第N个节点
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode result(0);
result.next=head;
for(int i=0;i<n;i++){
head=head->next;
}
ListNode *temp=&result;
while(head!=NULL){
head=head->next;
temp=temp->next;
}
ListNode *trash=temp->next;
temp->next=trash->next;
delete trash;
return result.next;
}
};#20.有效的括号
class Solution {
public:
bool isValid(string s) {
map<char,int> hashmap={{'(',1},{')',-1},{'{',2},{'}',-2},{'[',3},{']',-3}};
stack<int> _stack;
for(int i=0;i<s.size();i++){
if(hashmap[s[i]]>0){
_stack.push(hashmap[s[i]]);
}
else{
if(!_stack.empty() && (hashmap[s[i]]+_stack.top())==0){
_stack.pop();
}
else{
return false;
}
}
}
return _stack.empty();
}
};#21.合并两个有序链表
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode temp_head(0);
ListNode *pre=&temp_head;
while(l1 && l2){
if(l1->val < l2->val){
pre->next=l1;
l1=l1->next;
}
else{
pre->next=l2;
l2=l2->next;
}
pre=pre->next;
}
if(l1){
pre->next=l1;
}
if(l2){
pre->next=l2;
}
return temp_head.next;
}
};#22.括号生成
class Solution {
public:
vector<string> generateParenthesis(int n) {
vector<string> result;
int lc=0,rc=0;
DFS(result,"",n,lc,rc);
return result;
}
private:
void DFS(vector<string>& result,string path,int n,int lc ,int rc){
if(rc>lc || lc>n || rc>n){
return;
}
if(lc==rc && lc==n){
result.push_back(path);
}
DFS(result,path+'(',n,lc+1,rc);
DFS(result,path+')',n,lc,rc+1);
}
};
#23.合并K个排序链表
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* mergeKLists(vector<ListNode*>& lists) {
if(lists.size()==0)
{
return NULL;
}
if(lists.size()==1)
{
return lists[0];
}
if(lists.size()==2)
{
return mergeTwoLIsts(lists[0],lists[1]);
}
int mid=lists.size()/2;
vector<ListNode*> sub_lis1,sub_lis2;
for(int i=0;i<mid;i++)
{
sub_lis1.push_back(lists[i]);
}
for(int i=mid;i<lists.size();i++)
{
sub_lis2.push_back(lists[i]);
}
ListNode* l1=mergeKLists(sub_lis1);
ListNode* l2=mergeKLists(sub_lis2);
return mergeTwoLIsts(l1,l2);
}
private:
ListNode* mergeTwoLIsts(ListNode* lists1,ListNode* lists2)
{
if(lists1==NULL)
{
return lists2;
}
if(lists2==NULL)
{
return lists1;
}
ListNode temp(0);
ListNode* result=&temp;
while(lists1 && lists2)
{
if(lists1->val < lists2->val)
{
result->next=lists1;
lists1=lists1->next;
}
else
{
result->next=lists2;
lists2=lists2->next;
}
result=result->next;
}
if(!lists1)
{
result->next=lists2;
}
if(!lists2)
{
result->next=lists1;
}
return temp.next;
}
};#26.删除排序数组中的重复项
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
if(nums.size()==0){
return 0;
}
int i=0;
for(int j=1;j<nums.size();j++){
if(nums[i]!=nums[j]){
i++;
nums[i]=nums[j];
}
}
return i+1;
}
};#28.实现strStr()
class Solution {
public:
int strStr(string haystack, string needle) {
// 特殊情况判断
if(haystack.length() < needle.length()) return -1;
if(needle.length() == 0) return 0;
// 双指针，i指向haystack，j指向needle
int i = 0, j = 0;
while(i < haystack.length()) {
// 判断当前两个字符是否相等
if(haystack[i] == needle[j]) {
// 相等，则i，j自增1，若此时j越界，则找到索引
j++;
i++;
if(j >= needle.length())
return i - j;
}
else {
// 不相等，判断j是否越界
if(j < needle.length()) {
//未越界，则i重置为haystack中与needle的第一个字符相等的第一个字符位置的后一位，j重置为0
i = i - j + 1;
j = 0;
}
else {
// 越界，i自增1
i++;
}
}
}
return -1;
}
};
#29.两数相除
class Solution {
public:
int divide(int dividend, int divisor) { // 被除数 除数
if(dividend==INT_MIN&&divisor==-1)return INT_MAX;
if(dividend==divisor)return 1;
int sum=0,t=0;//第一层累加数
int sums=0,ts=0;//第二层累加数
int sumss=0,tss=0;//第三层累加数
int res=0;
int flat=(dividend^divisor);//结果正负标志位
dividend=(dividend<0)?dividend:-dividend;//被除数取负值
divisor=(divisor<0)?divisor:-divisor;//除数取负值
while(dividend<=divisor){//暴力累加法
sum+=divisor;
t--;
if(sums>INT_MIN-sum){//判断第一层累加是否超出
sums+=sum;
ts+=t;
}
if(sumss>INT_MIN-sums){//判断第二层累加是否超出
sumss+=sums;
tss+=ts;
}
if(dividend-sumss<0){//判断三层累加是否超出
res+=tss;
dividend-=sumss;
}else{//超出则普通累加
res--;
dividend-=divisor;
sum=0;
t=0;
sums=0;
ts=0;
sumss=0;
tss=0;
}
}
return(flat<0)?res:-res;
}
};#33.搜索旋转排序数组
class Solution {
public:
int search(vector<int>& nums, int target) {
int begin=0;
int end=nums.size()-1;
while(begin<=end){
int mid=(begin+end)/2;
if(nums[mid]==target){
return mid;
}
else if(target<nums[mid]){
if(nums[begin]<nums[mid]){
if(nums[begin]<=target){
end=mid-1;
}
else{
begin=mid+1;
}
}
else if(nums[begin]>nums[mid]){
end=mid-1;
}
else if(nums[begin]==nums[mid]){
begin=mid+1;
}
}
else if(target > nums[mid]){
if(nums[begin]<nums[mid]){
begin=mid+1;
}
else if(nums[begin] > nums[mid]) {
if(nums[begin]>target){
begin=mid+1;
}
else if(nums[begin]<=target){
end=mid-1;
}
}
else if(nums[begin]==nums[mid]){
begin=mid+1;
}
}
}
return -1;
}
};#34.在排序数组中查找元素的第一个和最后一个位置
class Solution {
public:
vector<int> searchRange(vector<int>& nums, int target) {
int begin=0;
int end=nums.size()-1;
vector<int> range={-1,-1};
//查找区间左端点
while(begin<=end){
int mid=(begin+end)/2;
if(target == nums[mid]){
//找到左端点
if(mid==0 || target>nums[mid-1]){
range[0]=mid;
break;
}
else{
end=mid-1;
}
}
else if(target > nums[mid]){
begin=mid+1;
}
else{
end=mid-1;
}
}
if(range[0]==-1){
return range;
}
//查找区间右端点
begin=range[0];
end=nums.size()-1;
while(begin<=end){
int mid=(begin+end)/2;
if(target == nums[mid]){
//找到右端点
if(mid==nums.size()-1 || target<nums[mid+1]){
range[1]=mid;
break;
}
else{
begin=mid+1;
}
}
else if(target > nums[mid]){
begin=mid+1;
}
else{
end=mid-1;
}
}
return range;
}
};#36.有效的数独
class Solution {
public:
bool isValidSudoku(vector<vector<char>>& board) {
//三个哈希表
int row[9][10]={0};
int col[0][10]={0};
int box[0][10]={0};
for(int i=0;i<9;i++){
for(int j=0;j<9;j++){
if(board[i][j]=='.'){
continue;
}
int curNumber=board[i][j]-'0';
if(row[i][curNumber]!=0) return false;
if(col[j][curNumber]!=0) return false;
if(box[(i/3)*3+j/3][curNumber]!=0) return false;
row[i][curNumber]=1;
col[j][curNumber]=1;
box[(i/3)*3+j/3][curNumber]=1;
}
}
return true;
}
};
#38.外观数列
class Solution {
public:
string countAndSay(int n) {
if(n==1) return"1";
string pre=countAndSay(n-1);
string ans;
int i=0;
for(int j=0;j<=pre.size();j++){
if(pre[i]==pre[j]){
continue;
}
else{
ans+=to_string(j-i)+pre[i];
i=j;
}
}
return ans;
}
};
#46.全排列
class Solution {
public:
vector<vector<int>> permute(vector<int>& nums) {
vector<vector<int>> result;
vector<int> path;
set<int> visited;
DFS(result,path,nums,visited);
return result;
}
private:
void DFS(vector<vector<int>> &result,vector<int>&path,vector<int> &nums,set<int> &visited){
if(visited.size()==nums.size()){
result.push_back(path);
return;
}
for(int i=0;i<nums.size();i++){
if(visited.find(i)==visited.end()){
visited.insert(i);
path.push_back(nums[i]);
DFS(result,path,nums,visited);
visited.erase(i);
path.pop_back();
}
}
}
};
#48.旋转图像
class Solution {
public:
void rotate(vector<vector<int>>& matrix) {
int n=matrix.size();
for(int i=0;i<(n+1)/2;i++){
for(int j=0;j<n/2;j++){
int temp = matrix[n - 1 - j][i];
matrix[n - 1 - j][i] = matrix[n - 1 - i][n - j - 1];
matrix[n - 1 - i][n - j - 1] = matrix[j][n - 1 -i];
matrix[j][n - 1 - i] = matrix[i][j];
matrix[i][j] = temp;
}
}
}
};
#49.字母异位词分组
class Solution {
public:
vector<vector<string>> groupAnagrams(vector<string>& strs) {
vector<vector<string>> result;
//哈希表
std::map<string,vector<string>> anagram_hash;
for(int i=0;i<strs.size();i++){
//先对str排序；
string temp=strs[i];
std::sort(temp.begin(),temp.end());
//如果有同组元素则添加
if(anagram_hash.find(temp)!=anagram_hash.end()){
anagram_hash[temp].push_back(strs[i]);
}
else{
//创建新的
vector<string> new_vecstr;
anagram_hash[temp]=new_vecstr;
anagram_hash[temp].push_back(strs[i]);
}
}
std::map<string,vector<string>>::iterator iter;
iter=anagram_hash.begin();
while(iter!=anagram_hash.end()){
result.push_back(iter->second);
iter++;
}
return result;
}
};#50.Pow(x,n)
注意int负数的越界情况，要用long long
class Solution {
public:
double myPow(double x, int n) {
long long N=n;
if(N<0){
return 1.0/_pow(x,-N);
}
return _pow(x,N);
}
private:
double _pow(double x,long long n ){
if(n==0){
return 1.0;
}
double y=_pow(x,n/2);
return n%2?y*y*x:y*y;
}
};
#53.最大子序和
class Solution {
public:
int maxSubArray(vector<int>& nums) {
int result=0;
vector<int> dp(nums.size(),0);
dp[0]=nums[0];
result=dp[0];
for(int i=1;i<nums.size();i++){
dp[i]=std::max(dp[i-1]+nums[i],nums[i]);
if(dp[i]>result){
result=dp[i];
}
}
return result;
}
};#54.螺旋矩阵
class Solution {
public:
vector<int> spiralOrder(vector<vector<int>>& matrix) {
if(matrix.size()==0 || matrix[0].size()==0){
return {};
}
static const int dx[4]={0,1,0,-1};
static const int dy[4]={1,0,-1,0};
vector<int> result;
int rows=matrix.size();
int cols=matrix[0].size();
vector<vector<int>> visit(rows,vector<int>(cols,0));
int newx=0,newy=0;
int index=0;
for(int i=0;i<rows*cols;i++){
result.push_back(matrix[newx][newy]);
visit[newx][newy]=1;
if(newx+dx[index]<0 || newx+dx[index]>=rows ||newy+dy[index]<0 || newy+dy[index]>=cols || visit[newx+dx[index]][newy+dy[index]]==1){
index=(index+1)%4;
}
newx+=dx[index];
newy+=dy[index];
}
return result;
}
};
#55.跳跃游戏
class Solution {
public:
bool canJump(vector<int>& nums) {
std::vector<bool> isArrive(nums.size(),false);
int max=0;
int last=-1;
for(int i=0;i<=max && max<nums.size() ;i++){
if(i+nums[i]>max){
max=i+nums[i];
printf("max:%d\n",max);
}
if(last==i){
break;
}
last=i;
printf("last:%d\n",last);
}
return (max >= nums.size()-1)?true:false;
}
};#56.合并区间
class Solution {
public:
vector<vector<int>> merge(vector<vector<int>>& intervals) {
if(intervals.size()==0){
return {};
}
std:sort(intervals.begin(),intervals.end(),cmp());
vector<vector<int>> result;
for(int i=0;i<intervals.size();i++){
int L=intervals[i][0];
int R=intervals[i][1];
if(result.empty() || result.back()[1]<L){
result.push_back({L,R});
}
else{
result.back()[1]=max(R,result.back()[1]);
}
}
return result;
}
private:
struct cmp{
bool operator()(vector<int> &A,vector<int> &B){
return A[0]<B[0];
}
};
};
#62.不同路径
class Solution {
public:
int uniquePaths(int m, int n) {
vector<vector<int>> dp(m,vector<int>(n,0));
dp[0][0]=1;
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
if(i-1>=0){
dp[i][j]+=dp[i-1][j];
}
if(j-1>=0){
dp[i][j]+=dp[i][j-1];
}
}
}
return dp[m-1][n-1];
}
};#66.加一
class Solution {
public:
vector<int> plusOne(vector<int>& digits) {
int num=1;
for(int i=digits.size()-1;i>=0;i--){
digits[i]+=num;
num=digits[i]/10;
digits[i]=digits[i]%10;
if(num==0){
break;
}
}
if(num){
digits.insert(digits.begin(),1);
}
return digits;
}
};#69.x的平方根
class Solution {
public:
int mySqrt(int x) {
int l=0,r=x,ans=-1;
while(l<=r){
int mid=(l+r)/2;
if((long long)mid*mid<=x){
ans=mid;
l=mid+1;
}
else{
r=mid-1;
}
}
return ans;
}
};
#70.爬楼梯
class Solution {
public:
int climbStairs(int n) {
//注意：n+3是为了防止传进来0时运行出错
vector<int> dp(n+3,0);
dp[1]=1;
dp[2]=2;
for(int i=3;i<=n;i++){
dp[i]=dp[i-1]+dp[i-2];
}
return dp[n];
}
};#73.矩阵置零
class Solution {
public:
void setZeroes(vector<vector<int>>& matrix) {
bool flag = false; //用作第一列的标识位
int m = matrix.size(), n = matrix[0].size();
for(int i = 0; i < m; ++i) //设置标识位
{
if(matrix [i][0] == 0) flag = true; //单独判断第一列的情况
for(int j = 1; j < n; ++j)
{
if(matrix[i][j] == 0) matrix[i][0] = matrix[0][j] = 0;
}
}
for(int i = m-1; i >= 0; --i) //更新数值时，因为标识位都在左上角，所以自下而上更新0值
{
for(int j = n-1; j >= 1; --j)
{
if(matrix[i][0] == 0 || matrix [0][j] == 0)
matrix[i][j] = 0;
}
if(flag) matrix[i][0] = 0; //第一列元素单独判断
}
}
};
#75.颜色分类
class Solution {
public:
void sortColors(vector<int>& nums) {
int p0=0;
int p2=nums.size()-1;
int cur=0;
while(cur<=p2){
if(nums[cur]==0){
nums[cur]=nums[p0];
nums[p0]=0;
p0++;
cur++;
}
else if(nums[cur]==2){
nums[cur]=nums[p2];
nums[p2]=2;
p2--;
}
else{
cur++;
}
}
}
};
#78.子集
class Solution {
public:
vector<vector<int>> subsets(vector<int>& nums) {
vector<vector<int>> result;
vector<int> path;
result.push_back(path);
_subsets(result,path,0,nums);
return result;
}
private:
void _subsets(vector<vector<int>> &result,vector<int> &path,int index,vector<int>& nums){
if(index>=nums.size()){
return;
}
path.push_back(nums[index]);
result.push_back(path);
_subsets(result,path,index+1,nums);
path.pop_back();
_subsets(result,path,index+1,nums);
}
};#79.单词搜索
static const int dx[]={1,-1,0,0};
static const int dy[]={0,0,1,-1};
class Solution {
public:
bool exist(vector<vector<char>>& board, string word) {
if(board.size()==0){
return false;
}
vector<vector<int>> visit(board.size(),vector<int>(board[0].size(),0));
for(int i=0;i<board.size();i++){
for(int j=0;j<board[0].size();j++){
if(DFS(board,visit,i,j,0,word)){
return true;
}
}
}
return false;
}
private:
bool DFS(vector<vector<char>> &board, vector<vector<int>> &visit,int newx,int newy,int index,string word){
if(index==word.size()-1){
return board[newx][newy]==word[index];
}
if(board[newx][newy]==word[index]){
visit[newx][newy]=1;
for(int i=0;i<4;i++){
int tempx = newx+dx[i];
int tempy = newy+dy[i];
if(tempx>=0 && tempx<board.size() && tempy>=0 && tempy<board[0].size() && visit[tempx][tempy]==0){
if( DFS(board,visit,tempx,tempy,index+1,word)){
return true;
}
}
}
visit[newx][newy]=0;
}
return false;
}
};
#88.合并两个有序数组
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
int i=m+n-1;
m--;
n--;
while(n>=0){
while(m>=0 && nums1[m]>nums2[n]){
nums1[i]=nums1[m];
i--;
m--;
}
nums1[i]=nums2[n];
i--;
n--;
}
}
};
#94.二叉树的中序遍历
递归
/**
* 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> inorderTraversal(TreeNode* root) {
vector<int> result;
midorder(root,result);
return result;
}
private:
void midorder(TreeNode *node,vector<int> &result){
if(node==NULL){
return;
}
midorder(node->left,result);
result.push_back(node->val);
midorder(node->right,result);
}
};非递归
/**
* 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> inorderTraversal(TreeNode* root) {
vector<int> result;
stack<TreeNode*> _stack;
TreeNode *p=root;
while(!_stack.empty() || p!=NULL){
if(p!=NULL){
_stack.push(p);
p=p->left;
}
else{
p=_stack.top();
result.push_back(p->val);
_stack.pop();
p=p->right;
}
}
return result;
}
};
173
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
