LeetCode 热题 C++ 215. 数组中的第K个最大元素 221. 最大正方形 226. 翻转二叉树 234. 回文链表 236. 二叉树的最近公共祖先

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;
    }
};