没有趟不过的河

class Solution {public: vector inorderTraversal(TreeNode *root) { vector res; stack s; TreeNode * p = root; while(p!=NULL||!s.empty()) { while(

class Solution {public: int climbStairs(int n) { vector<int> table; table.push_back(0); table.push_back(1); table.push_back(2); if(n<=2) return

class Solution {public: vector<vector<int> > subsets(vector<int> &S) { vector<vector<int>> res; vector<int> list; if(S.size()==0) { res.push_back(list);

1:class Solution {public: void sortColors(int A[], int n) { int b[3] = {0,0,0}; for(int i=0;i<n;i++) { b[A[i]]++; } int i=0,j=0,k=0; for

/** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solutio

其实该题为求连通子图的个数，可以借助DFS的思想：class Solution {public: bool dfs(int i,int j,vector<vector<char>> &grid) { if(i>=0&&i<grid.size()&&j>=0&&j<grid[i].size()&&grid[i][j]=='1') {

class Solution {public: int romanToInt(string s) { int map[128]; if(s.size()==0) return 0; map['I']=1; map['V']=5; map['X']=10; map['L'

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode *rot

注意越界！class Solution {public: int trailingZeroes(int n) { int sum = 0; long long i =5; while(i<=n) { sum += n/i; i *= 5; } re

class Solution {public: int searchLowerBound(int A[], int n, int target) { int left=0,right=n-1,res=-1; while(left<=right) { int mid = left+((right-left)>>

class Solution { vector > ret; int N; public: void perm(vector &num, int i){ if( i == N){ ret.push_back(num); } for(int j = i; j < N;

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode *pa

class Solution {public: vector preorderTraversal(TreeNode *root) { vector res; stack s; TreeNode * p = root; while(p!=NULL||!s.empty()) { while

class Solution {public: vector postorderTraversal(TreeNode *root) { vector res; stack>s; TreeNode *p = root; while(p!=NULL||!s.empty()) { while

class Solution {public: int divide(int dividend, int divisor) { long long div = dividend,dis = divisor; div = abs(div); dis = abs(dis); long long res = 0; w

/** * Definition for binary tree with next pointer. * struct TreeLinkNode { * int val; * TreeLinkNode *left, *right, *next; * TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {

class Solution {public: void rotate(int nums[], int n, int k) { k = k%n; reverse(nums,0,n-k-1); reverse(nums,n-k,n-1); reverse(nums,0,n-1); } voi

class Solution {public: char hash[1024*1024]; vector findRepeatedDnaSequences(string s) { vector res; if(s.size()<10) return res; char convertor[26];

1：class Solution {public: int hammingWeight(uint32_t n) { int count = 0; while(n) { if(n&0x1==1) { count++; }

class Solution {public: uint32_t reverseBits(uint32_t n) { uint32_t m = 0; for(int i=0;i<32;i++) { m = (m<<1)+(n&0x1); n = n>>1; }

最开始我犯了个错误，直接递归判断根节点的值是否在左孩子节点和右孩子节点值得中间，忽略了应该是根节点的值大于左子树所有节点的值，小于右子树所有节点的值，导致代码如下：bool isValidBST(TreeNode* root) { if(root==NULL) return true; else if(root->left&&!root->ri