这里写目录标题
1.重建二叉树
题目
题解
(递归) O(n)
递归建立整棵二叉树：先递归创建左右子树，然后创建根节点，并让指针指向两棵子树。
前序遍历（根 左 右）中序遍历（左 根 右） 后序遍历（左 右 根）
具体步骤如下：
- 先利用前序遍历找根节点：前序遍历（根 左 右）的第一个数，就是根节点的值；
- 在中序遍历中找到根节点的位置 k，则 k 左边是左子树的中序遍历（左 根 右），右边是右子树的中序遍历；
- 假设左子树的中序遍历的长度是 l，则在前序遍历中，根节点后面的 l 个数，是左子树的前序遍历，剩下的数是右子树的前序遍历；
- 有了左右子树的前序遍历和中序遍历，我们可以先递归创建出左右子树，然后再创建根节点；
时间复杂度分析
我们在初始化时，用哈希表(unordered_map<int,int>)记录每个值在中序遍历中的位置，这样我们在递归到每个节点时，在中序遍历中查找根节点位置的操作，只需要 O(1) 的时间。此时，创建每个节点需要的时间是 O(1)，所以总时间复杂度是 O(n)。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
//preorder前序遍历（根 左 右），inorder中序遍历（左 根 右）
class Solution {
public:
unordered_map<int, int> pos;
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
int n = preorder.size();
for (int i = 0; i < n; ++i)
pos[inorder[i]] = i; //用哈希表记录每个值在中序遍历中的位置
return dfs(preorder, inorder, 0, n - 1, 0, n - 1);
}
//前序遍历pre的范围是[pl,pr], 中序遍历in的范围是[il,ir]
TreeNode* dfs(vector<int>& pre, vector<int>& in, int pl, int pr, int il, int ir) {
if (pl > pr) return NULL;
int k = pos[pre[pl]] - il; //寻找前序的根节点在中序遍历中是在第几个位置
TreeNode* root = new TreeNode(pre[pl]); //生成新的根节点
root->left = dfs(pre, in, pl + 1, pl + k, il, il + k - 1);
root->right = dfs(pre, in, pl + k + 1, pr, il + k + 1, ir);
return root;
}
};
2.二叉树的下一个节点
题目
题解
(模拟) O(h)
这道题目就是让我们求二叉树中给定节点的后继。
中序遍历（左 根 右）
分情况讨论即可，如下图所示：
- （左 根 右）如果当前节点有右儿子，则右子树中最左侧的节点就是当前节点的后继。比如F的后继是H；
- （左 根）如果当前节点没有右儿子，**则需要沿着father域一直向上找，找到第一个是其(这个其非当前节点)father左儿子的节点，该节点的father就是当前节点的后继。**比如当前节点是D，则第一个满足是其father左儿子的节点是F，则C的father就是D的后继，即F是D的后继。
时间复杂度分析
不论往上找还是往下找，总共遍历的节点数都不大于树的高度。所以时间复杂度是 O(h)，其中 h 是树的高度。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode *father;
* TreeNode(int x) : val(x), left(NULL), right(NULL), father(NULL) {}
* };
*/
class Solution{
public:
TreeNode* inorderSuccessor(TreeNode* p) {
if (p->right) {
p = p->right; //易错带
while (p->left) p = p->left;
return p;
}
//p == p->father->right 用来判断p是否是右节点
while (p->father && p == p->father->right) p = p->father;
return p->father;
}
};
3.用两个栈实现队列
题目
题解
(栈，队列) O(n)
这是一道基础题，只要把功能实现对就可以，不需要考虑运行效率。
我们用两个栈来做，一个主栈，用来存储数据；一个辅助栈，用来当缓存。
栈：先进后出，队列：先进先出
push(x)，我们直接将 x 插入主栈中即可。pop()，此时我们需要弹出最先进入栈的元素，也就是栈底元素。我们可以先将所有元素从主栈中弹出，压入辅助栈中。则辅助栈的栈顶元素就是我们要弹出的元素，将其弹出即可。然后再将辅助栈中的元素全部弹出，压入主栈中。peek()，可以用和pop()操作类似的方式，得到最先压入栈的元素。empty()，直接判断主栈是否为空即可。
时间复杂度分析
push()：O(1)；pop(): 每次需要将主栈元素全部弹出，再压入，所以需要 O(n) 的时间；peek()：类似于pop()，需要 O(n) 的时间；empty()：O(1)；
class MyQueue {
public:
/** Initialize your data structure here. */
stack<int> stk, cache;
MyQueue() { //初始化，如果栈不为空，则用while()清空
while (!stk.empty()) {
stk.pop();
}
while (!cache.empty()) {
cache.pop();
}
}
/** Push element x to the back of queue. */
void push(int x) {
stk.push(x);
}
void copy(stack<int>& a, stack<int>& b) {
while (a.size()) {
b.push(a.top());
a.pop();
}
}
/** Removes the element from in front of queue and returns that element. */
int pop() {
if (stk.empty()) return -1; //如果栈为空，返回-1
copy(stk, cache);
int res = cache.top();
cache.pop();
copy(cache, stk);
return res;
}
/** Get the front element. */
int peek() {
if (stk.empty()) return NULL; //如果栈为空，返回NULL
copy(stk, cache);
int res = cache.top();
copy(cache, stk);
return res;
}
/** Returns whether the queue is empty. */
bool empty() {
return stk.empty();
}
};
/**
* Your MyQueue object will be instantiated and called as such:
* MyQueue obj = MyQueue();
* obj.push(x);
* int param_2 = obj.pop();
* int param_3 = obj.peek();
* bool param_4 = obj.empty();
*/
4.斐波那契数列
题目
题解
(递推 + 滚动变量) O(n)
这题的数据范围很小，我们直接模拟即可。
当数据范围很大时，就需要采用其他方式了，可以参考 求解斐波那契数列的若干方法 。
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。
用两个变量滚动式得往后计算，a 表示第 n−1 项，b 表示第 n 项。
则令 c=a+b 表示第 n+1 项，然后让 a, b 顺次往后移一位。
时间复杂度分析
总共需要计算 n 次，所以时间复杂度是 O(n) ，但空间复杂度变成了 O(1)。
class Solution {
public:
const int MOD = 1e9 + 7; //1000000007
int Fibonacci(int n) {
int a = 0, b = 1;
while (n--)
{
int c = (a + b) % MOD; //取模优先级比加减高，比乘数低
a = b, b = c; //逗号运算符，从左到右计算
}
return a;
}
};
// 0 1 1 2 3 5
//第几项 0 1 2 3 4 5
剑指offer 10 - II 青蛙跳台阶问题
题目
题解
此类求 多少种可能性 的题目一般都有 递推性质 ，即 f(n) 和 f(n-1)…f(1) 之间是有联系的。
计算 f(n) 需循环 n 次，每轮循环内计算操作使用 O(1) ，所以时间复杂度是 O(n) 。
几个标志变量使用常数大小的额外空间，空间复杂度为 O(1)。
class Solution {
public:
const int MOD = 1e9 + 7; //1000000007
int numWays(int n) {
int a = 1, b = 1; //只有起始条件不同，其它都与上题相同
while (n--)
{
int c = (a + b) % MOD; //取模优先级比加减高，比乘数低
a = b, b = c; //逗号运算符，从左到右计算
}
return a;
}
};
5.旋转数组的最小数字
题目
题解
(二分) O(n)
为了便于分析，我们先将数组中的数画在二维坐标系中，横坐标表示数组下标，纵坐标表示数值， 图中水平的实线段表示相同元素。如下所示：
我们发现除了最后水平的一段（黑色水平那段）之外，其余部分满足二分性质：竖直虚线左边的数满足 nums[i]≥nums[0]；而竖直虚线右边的数不满足这个条件。
二分是二分性而不是单调性。只要满足可以找到一个值一半满足一半不满足即可，而不用满足单调性。
分界点就是整个数组的最小值，所以我们先将最后水平的一段删除即可。
另外，不要忘记处理数组完全单调的特殊情况：
当我们删除最后水平的一段之后，如果剩下的最后一个数大于等于第一个数，则说明数组完全单调。
时间复杂度分析
二分的时间复杂度是 O(logn)，删除最后水平一段的时间复杂度最坏是 O(n)，所以总时间复杂度是 O(n)。
class Solution
{
public:
int findMin(vector<int>& nums)
{
int n = nums.size() - 1;
if(n < 0) return -1;
while (n > 0 && nums[n] == nums[0]) n--; //删除最后水平的一段，当n=0时，只有一个数，也要退出循环
if (nums[n] >= nums[0]) return nums[0]; //当没有元素旋转时，则出现这种情况
int l = 0, r = n;
while (l < r) {
int mid = l + r >> 1; //[l, mid], [mid + 1, r]
if (nums[mid] < nums[0]) r = mid;
else l = mid + 1;
}
return nums[r];
}
};
559
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
