LeetCode215
给定整数数组 nums
和整数 k
,请返回数组中第 k
个最大的元素。
请注意,你需要找的是数组排序后的第 k
个最大的元素,而不是第 k
个不同的元素。
你必须设计并实现时间复杂度为 O(n)
的算法解决此问题。
示例 1:
输入: [3,2,1,5,6,4],
k = 2
输出: 5
示例 2:
输入: [3,2,3,1,2,4,5,5,6],
k = 4
输出: 4
提示:
1 <= k <= nums.length <= 105
-104 <= nums[i] <= 104
思路:
快速选择。
我无语了!改了半天函数,要么超时要么RE,最后摆烂加了句特判,OK过了。,
代码:
class Solution {
public:
int ans=0;
void kk(vector<int>& nums, int k,int left,int right)
{
if(left>right)return;
int i=left;
int j=right+1;
while(true)
{
while(nums[++i]>nums[left]){
if(i==right)break;
}
while(nums[--j]<nums[left]){
if(j==left)break;
}
if(i>=j)break;
swap(nums[i],nums[j]);
}
swap(nums[j],nums[left]);
if(j>k-1)kk(nums,k,left,j-1);
else if(j<k-1)kk(nums,k,j+1,right);
else{
ans=nums[j];
return;
}
}
int findKthLargest(vector<int>& nums, int k) {
if(nums.size()==1)return nums[0];
if(nums.size()==2){
if(k==1){
if(nums[0]>nums[1])return nums[0];
else return nums[1];
}
else if(k==2)
{
if(nums[0]>nums[1])return nums[1];
else return nums[0];
}
}
kk(nums,k,0,nums.size()-1);
return ans;
}
};
LeetCode221
在一个由 '0'
和 '1'
组成的二维矩阵内,找到只包含 '1'
的最大正方形,并返回其面积。
示例 1:
输入:matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]] 输出:4
示例 2:
输入:matrix = [["0","1"],["1","0"]] 输出:1
示例 3:
输入:matrix = [["0"]] 输出:0
提示:
m == matrix.length
n == matrix[i].length
1 <= m, n <= 300
matrix[i][j]
为'0'
或'1'
思路:
动态规划。
代码:
class Solution {
public:
int maximalSquare(vector<vector<char>>& matrix) {
int dp[305][305];
memset(dp,0,sizeof(dp));
int ans=0;
for(int i=0;i<matrix.size();i++)
{
for(int j=0;j<matrix[0].size();j++)
{
if(matrix[i][j]=='1'){
if(i==0){
dp[i][j]=1;
}
else if(j==0){
dp[i][j]=1;
}
else{
if(matrix[i][j]=='1')dp[i][j]=min(dp[i-1][j-1],min(dp[i-1][j],dp[i][j-1]))+1;
}
}
ans=max(ans,dp[i][j]);
}
}
return ans*ans;
}
};
LeetCode226
给你一棵二叉树的根节点 root
,翻转这棵二叉树,并返回其根节点。
示例 1:
输入:root = [4,2,7,1,3,6,9] 输出:[4,7,2,9,6,3,1]
示例 2:
输入:root = [2,1,3] 输出:[2,3,1]
示例 3:
输入:root = [] 输出:[]
提示:
- 树中节点数目范围在
[0, 100]
内 -100 <= Node.val <= 100
思路:
递归。
代码:
/**
* 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:
void f(TreeNode* p){
if(p==NULL)return;
TreeNode* t=p->left;
p->left=invertTree(p->right);
p->right=invertTree(t);
}
TreeNode* invertTree(TreeNode* root) {
TreeNode* t=root;
f(t);
return root;
}
};
LeetCode234
给你一个单链表的头节点 head
,请你判断该链表是否为回文链表。如果是,返回 true
;否则,返回 false
。
示例 1:
输入:head = [1,2,2,1] 输出:true
示例 2:
输入:head = [1,2] 输出:false
提示:
- 链表中节点数目在范围
[1, 105]
内 0 <= Node.val <= 9
进阶:你能否用 O(n)
时间复杂度和 O(1)
空间复杂度解决此题?
思路:
先计算链表的长度。然后取一半的位置。
前一半入栈,然后后一半和出栈的数字比较。
代码:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
bool isPalindrome(ListNode* head) {
int len=0;
ListNode* p=head;
while(p)
{
len++;
p=p->next;
}
int half=len/2;
stack<int> s;
p=head;
while(half--)
{
s.push(p->val);
p=p->next;
}
if(len%2==1)p=p->next;
int a;
while(p)
{
a=s.top();
s.pop();
if(p->val!=a)return 0;
p=p->next;
}
return 1;
}
};
LeetCode236
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为:“对于有根树 T 的两个节点 p、q,最近公共祖先表示为一个节点 x,满足 x 是 p、q 的祖先且 x 的深度尽可能大(一个节点也可以是它自己的祖先)。”
示例 1:
输入:root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出:3 解释:节点5
和节点1
的最近公共祖先是节点3 。
示例 2:
输入:root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出:5 解释:节点5
和节点4
的最近公共祖先是节点5 。
因为根据定义最近公共祖先节点可以为节点本身。
示例 3:
输入:root = [1,2], p = 1, q = 2 输出:1
提示:
- 树中节点数目在范围
[2, 105]
内。 -109 <= Node.val <= 109
- 所有
Node.val
互不相同
。 p != q
p
和q
均存在于给定的二叉树中。
思路:
代码:
/**
* 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||root==p||root==q)return root;
TreeNode* left=lowestCommonAncestor(root->left,p,q);
TreeNode* right=lowestCommonAncestor(root->right,p,q);
if(left==NULL&&right==NULL)return NULL;
if(left==NULL)return right;
if(right==NULL)return left;
return root;
}
};