老师，写递归函数的时候，是按照伪代码一步一步翻译成代码么？这样就行了吗？真的是不能细想，一想就会迷惑这程序为什么要这样写[笑哭][笑哭]
递归可以看成是一种新的思维方式，必须要尽量理解，以后学数据结构会大量使用的。
用“自然语言”实现代码就是递归的魅力，习惯了这种编程方式就好了。
111. 二叉树的最小深度
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明: 叶子节点是指没有子节点的节点。
示例:
给定二叉树 [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回它的最小深度 2.
通过次数130,151提交次数293,819
class Solution {
public:
int minDepth(TreeNode* root) {
if(root==NULL)
return 0;
if(root->left==NULL&&root->right !=NULL)
return minDepth(root->right)+1;
if(root->right==NULL&& root->left !=NULL)
return minDepth(root->left)+1;
int leftMinDepth=minDepth(root->left);
int rightMinDepth=minDepth(root->right);
return min(leftMinDepth,rightMinDepth)+1;
}
};
当出现[1,2]这种情况，就是说树已经退化成链表了，所以在求的时候需要判断一下如果左子树深度为0，那最小深度就是链表长度，即右子树深度，反之也可。
104. 二叉树的最大深度
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3
/ \
9 20
/ \
15 7
返回它的最大深度 3 。
通过次数265,446提交次数354,273
class Solution {
public:
int maxDepth(TreeNode* root) {
if(root==NULL) return 0;
int leftMaxDepth=maxDepth(root->left);
int rightMaxDepth=maxDepth(root->right);
return max(leftMaxDepth,rightMaxDepth)+1;
}
};
24. 两两交换链表中的节点
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例:
给定 1->2->3->4, 你应该返回 2->1->4->3.
通过次数143,629提交次数215,693
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
if(head==NULL||head->next==NULL)
return head;
ListNode* next=head->next;
head->next=swapPairs(next->next);
next->next=head;
return next;
}
};
226. 翻转二叉树
翻转一棵二叉树。
示例：
输入：
4
/ \
2 7
/ \ / \
1 3 6 9
输出：
4
/ \
7 2
/ \ / \
9 6 3 1
备注:
这个问题是受到 Max Howell 的 原问题 启发的 ：
谷歌：我们90％的工程师使用您编写的软件(Homebrew)，但是您却无法在面试时在白板上写出翻转二叉树这道题，这太糟糕了。
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
if(root==NULL)
return root;
TreeNode* tmp=root->left;
root->left=invertTree(root->right);
root->right=invertTree(tmp);
return root;
}
};
100. 相同的树
给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
示例 1:
输入: 1 1
/ \ / \
2 3 2 3
[1,2,3], [1,2,3]
输出: true
示例 2:
输入: 1 1
/ \
2 2
[1,2], [1,null,2]
输出: false
示例 3:
输入: 1 1
/ \ / \
2 1 1 2
[1,2,1], [1,1,2]
输出: false
通过次数136,858提交次数227,657
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
if(p==NULL&&q==NULL)
return true;
if((p==NULL&&q!=NULL)||(p!=NULL&&q==NULL)||p->val!=q->val)
return false;
bool num1=isSameTree(p->left,q->left);
bool num2=isSameTree(p->right,q->right);
return(num1&&num2);
}
};
剑指 Offer 10- I. 斐波那契数列
写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项。斐波那契数列的定义如下：
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
示例 1：
输入：n = 2
输出：1
示例 2：
输入：n = 5
输出：5
提示：
0 <= n <= 100
class Solution {
public:
int fib(int n) {
//if(n==0||n==1)
//return n;
//int sum=fib(n-1)+fib(n-2);
//return sum;
//超时
//动态规划的方法
if(n==0) return 0;
if(n==1) return 1;
vector<long long> dp(n + 1,0);//C++必须用vector
dp[1]=1;
for(int i=2;i<=n;i++){
dp[i]=(dp[i-1]+dp[i-2])%1000000007;
}
return dp[n];
}
};
101. 对称二叉树
给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
1
/ \
2 2
/ \ / \
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1
/ \
2 2
\ \
3 3
进阶：
你可以运用递归和迭代两种方法解决这个问题吗？
递归
class Solution {
public:
bool isEqual(TreeNode* p,TreeNode* q){
if((p==NULL&&q!=NULL)||(p!=NULL&&q==NULL))
return false;
if(p==NULL&&q==NULL)
return true;
if(p->val!=q->val)
return false;
return isEqual(p->left,q->right)&&isEqual(p->right,q->left);
}
//迭代
bool isEqual2(TreeNode* p,TreeNode* q){
queue<TreeNode*> qt;
qt.push(p);
qt.push(q);
while(!qt.empty()){
p=qt.front();
qt.pop();
q=qt.front();
qt.pop();
if(!q&&!p) continue;
if((!p||!q)||(p->val!=q->val))
return false;
qt.push(p->left);
qt.push(q->right);
qt.push(p->right);
qt.push(q->left);
}
return true;
}
bool isSymmetric(TreeNode* root) {
if(root==NULL)
return true;
return isEqual2(root->left,root->right);
}
};