春节刷题day11：LeetCode
剑指 Offer 68 - II. 二叉树的最近公共祖先
剑指 Offer 07. 重建二叉树
剑指 Offer 32 - III. 从上到下打印二叉树 III
剑指 Offer 34. 二叉树中和为某一值的路径
面试题 02.03. 删除中间节点
面试题 16.07. 最大数值
面试题 01.01. 判定字符是否唯一
面试题 03.04. 化栈为队
1、剑指 Offer 68 - II. 二叉树的最近公共祖先
/**
* 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:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
if(root == NULL) return NULL;
if(root == p || root == q) return root;
TreeNode* left = lowestCommonAncestor(root -> left, p, q);
TreeNode* right = lowestCommonAncestor(root -> right, p, q);
if(left && right) return root;
return left ? left : right;
}
};
/**
* 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:
TreeNode* ans = NULL;
int slove(TreeNode* root, TreeNode* p, TreeNode* q){
int node = 0;
if(root == NULL) return 0;
else if(root == p || root == q){
node = slove(root -> left, p, q) + slove(root -> right, p, q) + 1;
}else{
node = slove(root -> left, p, q) + slove(root -> right, p, q);
}
if(node == 2 && !ans){
ans = root; }
return node;
}
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
slove(root, p, q);
return ans;
}
};
2、剑指 Offer 07. 重建二叉树
/**
* 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:
TreeNode* slove(int idx, int st, int end, vector<int>& preorder, vector<int>& inorder){
if(st > end) return NULL;
int i = st;
while(i < end && preorder[idx] != inorder[i]) i++;
TreeNode* root = new TreeNode(preorder[idx]);
root -> left = slove(idx + 1, st, i - 1, preorder, inorder);
root -> right = slove(idx + 1 + i - st, i + 1, end, preorder, inorder);
return root;
}
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
return slove(0, 0, preorder.size() - 1, preorder, inorder);
}
};
/**
* 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:
unordered_map<int, int> pa;
TreeNode* slove(int idx, int st, int end, vector<int>& preorder, vector<int>& inorder){
if(st > end) return NULL;
int i = pa[preorder[idx]];
TreeNode* root = new TreeNode(preorder[idx]);
root -> left = slove(idx + 1, st, i - 1, preorder, inorder);
root -> right = slove(idx + 1 + i - st, i + 1, end, preorder, inorder);
return root;
}
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
int size = preorder.size();
for(int i = 0; i < size; i++) pa[inorder[i]] = i;
return slove(0, 0, size - 1, preorder, inorder);
}
};
3、剑指 Offer 32 - III. 从上到下打印二叉树 III
/**
* 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<vector<int>> levelOrder(TreeNode* root) {
vector< vector<int> > ans;
queue<TreeNode*> que;
if(!root) return ans;
que.push(root);
int tot = 1;
while(!que.empty()){
int Size = que.size();
stack<TreeNode*> st;
vector<int> ANS;
while(!que.empty()){
TreeNode* now = que.front();
ANS.push_back(now -> val);
st.push(now); que.pop();
}
while(!st.empty()){
que.push(st.top()); st.pop();
}
if(tot & 1){
while(Size--){
TreeNode* now = que.front(); que.pop();
if(now -> right) que.push(now -> right);
if(now -> left) que.push(now -> left);
}
}else{
while(Size--){
TreeNode* now = que.front(); que.pop();
if(now -> left) que.push(now -> left);
if(now -> right) que.push(now -> right);
}
}
ans.push_back(ANS);
tot++;
}
return ans;
}
};
4、剑指 Offer 34. 二叉树中和为某一值的路径
/**
* 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<vector<int>> ans;
vector<int> v;
void slove(TreeNode* root, int sum){
if(root == NULL) return ;
v.push_back(root -> val);
if(root != NULL && root -> left == NULL && root -> right == NULL){
if(sum == root -> val) ans.push_back(v);
}
slove(root -> left, sum - root -> val);
slove(root -> right, sum - root -> val);
v.pop_back();
}
vector<vector<int>> pathSum(TreeNode* root, int sum) {
slove(root, sum);
return ans;
}
};
/**
* 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<vector<int>> ans;
vector<int> v;
void slove(TreeNode* root, int sum){
if(root == NULL) return ;
v.push_back(root -> val);
if(root != NULL && root -> left == NULL && root -> right == NULL){
int ret = 0;
for(int i = 0; i < v.size(); i++) ret += v[i];
if(ret == sum) ans.push_back(v);
}
slove(root -> left, sum);
slove(root -> right, sum);
v.pop_back();
}
vector<vector<int>> pathSum(TreeNode* root, int sum) {
slove(root, sum);
return ans;
}
};
----------------------------------------我是分割线------------------------------------------
5、面试题 02.03. 删除中间节点
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
void deleteNode(ListNode* node) {
node -> val = node -> next -> val;
node -> next = node -> next -> next;
}
};
6、面试题 16.07. 最大数值
class Solution {
public:
int maximum(int a, int b) {
long long A = a;
long long B = b;
return (int)((abs(A - B) + A + B) / 2);
}
};
7、面试题 01.01. 判定字符是否唯一
class Solution {
public:
bool isUnique(string astr) {
int x = 0;
for(int i = 0; i < astr.size(); i++){
if(x & (1 << (astr[i] - 'a') ) ) return false;
x |= ( (1 << (astr[i] - 'a') ) );
}
return true;
}
};
8、面试题 03.04. 化栈为队
class MyQueue {
stack<int> st1, st2;
public:
/** Initialize your data structure here. */
MyQueue() {
}
/** Push element x to the back of queue. */
void push(int x) {
st1.push(x);
}
/** Removes the element from in front of queue and returns that element. */
int pop() {
int ans = peek();
st2.pop();
return ans;
}
/** Get the front element. */
int peek() {
if(st2.size() == 0){
while(!st1.empty()){
int now = st1.top(); st1.pop();
st2.push(now);
}
}
int ans = st2.top();
return ans;
}
/** Returns whether the queue is empty. */
bool empty() {
if(st1.size() == 0 && st2.size() == 0) return true;
return false;
}
};
/**
* Your MyQueue object will be instantiated and called as such:
* MyQueue* obj = new MyQueue();
* obj->push(x);
* int param_2 = obj->pop();
* int param_3 = obj->peek();
* bool param_4 = obj->empty();
*/
2021/2/17完结（明天就要上班了，咋感觉放假就在昨天，当社畜太难了，完全没得心思上班）。