leetcode每日一题:原题链接
leetcode-1630. 等差子数组
昨天和今天刚借着刷题复习了快速排序,今天又遇到需要排序的题目,不练白不练~
题目:
给你一个由 n 个整数组成的数组 nums,和两个由 m 个整数组成的数组 l 和 r,后两个数组表示 m 组范围查询,其中第 i 个查询对应范围 [l[i], r[i]] 。所有数组的下标都是 从 0 开始 的。
返回 boolean 元素构成的答案列表 answer 。如果子数组 nums[l[i]], nums[l[i]+1], … , nums[r[i]] 可以 重新排列 形成 等差数列 ,answer[i] 的值就是 true;否则answer[i] 的值就是 false 。
解题思路1:直接暴力模拟,题目怎么描述程序就怎么模拟,先复制全部数组或者一个子数组,然后根据区间去排序,之后对子数组里的有序的数列遍历模拟
时间复杂度O(l*log(l)), 代码如下:
class Solution {
public:
vector<bool> checkArithmeticSubarrays(vector<int>& nums, vector<int>& l, vector<int>& r) {
vector<bool> result;
int m = l.size();
int i;
vector<int> subNum;
for(i = 0; i < m; i++){
if(r[i] - l[i] + 1 <= 2){
result.push_back(true);
continue;
}
subNum = nums;
quickSort(subNum, l[i], r[i]);
result.push_back(isdc(subNum, l[i], r[i]));
}
return result;
}
bool isdc(vector<int>& nums, int start, int end){
int c = nums[start+1] - nums[start];
for(int i = start + 2; i <= end; i++){
if(nums[i] - nums[i-1] != c){
return false;
}
}
return true;
}
void quickSort(vector<int>&nums, int start, int end){
if(start >= end){
return;
}
int mid = nums[start];
int left = start;
int right = end;
while(left < right){
while(left < right && nums[right] > mid){
right--;
}
nums[left] = nums[right];
while(left < right && nums[left] <= mid){
left++;
}
nums[right] = nums[left];
}
nums[left] = mid;
quickSort(nums, start, left-1);
quickSort(nums, left+1, end);
return;
}
};
解题思路2:考虑等差数列的性质,找到等差序列的公差。优化一点时间开销(直接优化掉排序的时间)。
下面是常规顺序刷题,原题链接
222. 完全二叉树的节点个数
层序遍历法(广度优先搜索BFS),代码如下:
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int countNodes(TreeNode* root) {
int result = 0;
queue<TreeNode*> q;
int lsize, i;
TreeNode* cur;
if(root) q.push(root);
while(!q.empty()){
lsize = q.size();
result += lsize;
for(i = 0; i < lsize; i++){
cur = q.front();
q.pop();
if(cur->left) q.push(cur->left);
if(cur->right) q.push(cur->right);
}
}
return result;
}
};
递归法,分别考虑左子树和右子树,如果是满二叉树则直接计算(注意2的左移就是以2为底的乘方),否则递归计算,代码如下:
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int countNodes(TreeNode* root) {
if(!root) return 0;
TreeNode* leftNode = root->left;
TreeNode* rightNode = root->right;
int leftDepth = 0;
int rightDepth = 0;
while(leftNode){
leftDepth++;
leftNode = leftNode->left;
}
while(rightNode){
rightDepth++;
rightNode = rightNode->right;
}
if(leftDepth == rightDepth){
return (2 << leftDepth) -1;
}
return 1 + countNodes(root->left) + countNodes(root->right);
}
};
后序遍历判断平衡二叉树,原题链接
leetcode-110. 平衡二叉树
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
bool isBalanced(TreeNode* root) {
return getHeight(root) != -1;
}
int getHeight(TreeNode* root){
if(!root) return 0;
if(!root->left && !root->right){
return 1;
}
int leftHeight = getHeight(root->left);
if(leftHeight == -1){
return -1;
}
int rightHeight = getHeight(root->right);
if(rightHeight == -1){
return -1;
}
int result;
if(abs(leftHeight - rightHeight) > 1) {
result = -1;
}
else{
result = 1 + max(leftHeight, rightHeight);
}
return result;
}
};