LeetCode hot-100 简单and中等难度，11-20.

神秘的义勇神驹

于 2020-08-08 00:32:41 发布

阅读量146

点赞数

分类专栏： LeetCode面试题

本文链接：https://blog.csdn.net/qq_42671442/article/details/107870395

版权

LeetCode面试题专栏收录该内容

25 篇文章 0 订阅

订阅专栏

20. 有效的括号

难度简单1746收藏分享切换为英文关注反馈

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

注意空字符串可被认为是有效字符串。

示例 1:

输入: "()"
输出: true

示例 2:

输入: "()[]{}"
输出: true

示例 3:

输入: "(]"
输出: false

示例 4:

输入: "([)]"
输出: false

示例 5:

输入: "{[]}"
输出: true

//看了下官方题解，应该就还是个模拟题吧，普通模拟题？？
class Solution {
public:
    bool isValid(string s) {
        stack<char> st;
        if(s.length()==0) return true;
        st.push(s[0]);
        for(int i=1;i<s.length();i++){
            if(st.empty()&&(s[i]==')'||s[i]==']'||s[i]=='}')) return false;
            else if(st.empty()) st.push(s[i]);
            else if(st.top()=='('&&s[i]==')'){
                st.pop();
            }else if(st.top()=='['&&s[i]==']'){
                st.pop();
            }else if(st.top()=='{'&&s[i]=='}'){
                st.pop();
            }else{
                st.push(s[i]);
            }
        }
        return st.empty();
    }
};

21. 合并两个有序链表

难度简单1190收藏分享切换为英文关注反馈

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

除此之外还有递归写法...

/**
 * 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:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* l3=new ListNode(0);//哑结点
        ListNode* ans=l3;
        while(l1||l2){
            if(l1&&l2){
                if(l1->val<=l2->val){
                    l3->next = new ListNode(l1->val); l1=l1->next;
                }else{
                    l3->next= new ListNode(l2->val);l2=l2->next;
                }
                
            }else if(l1){
                l3->next=new ListNode(l1->val);
                l1=l1->next;
            }else{
                l3->next=new ListNode(l2->val);
                l2=l2->next;
            }
            l3=l3->next;
        }
        return ans->next;
    }
};

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* l3=new ListNode(0);//哑结点
        ListNode* ans=l3;
        while(l1||l2){
            if(l1&&l2){
                if(l1->val<=l2->val){
                    l3->next =l1; l1=l1->next;
                }else{
                    l3->next= l2;l2=l2->next;
                }
                l3=l3->next;
            }else if(l1){
                l3->next=l1;
                l1=NULL;
            }else{
                l3->next=l2;
                l2=NULL;
            }
            // l3=l3->next;
        }
        return ans->next;
    }
};

22. 括号生成

难度中等1218收藏分享切换为英文关注反馈

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例：

输入：n = 3
输出：[
       "((()))",
       "(()())",
       "(())()",
       "()(())",
       "()()()"
     ]

//其实就一个规则把，在最后一个括号之前，右括号的数量都不能超过左括号。
class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<string> res;
        get(n,0,0,"",res);
        return res;
    }
    void get(int n,int r,int l,string a,vector<string> &res){
        if(r>n||l>n||l>r) return;
        if(r==n&&l==n){
            res.push_back(a);return;
        }
        get(n,r+1,l,a+"(",res);
        get(n,r,l+1,a+")",res);
    }
};

第一种就是深度优先遍历la，在上面。（回溯+剪枝）

第二种广度优先遍历，得程序员自己编写结点类，显示使用队列这个数据结构。（很麻烦省略..)

第三种动态规划，

①dp[i]：使用 i 对括号能够生成的组合。

②i 对括号的一个组合，在 i - 1 对括号的基础上得到，这是思考 “状态转移方程” 的基础；
i 对括号的一个组合，一定以左括号 "(" 开始，不一定以 ")" 结尾。为此，我们可以枚举新的右括号 ")" 可能所处的位置，得到所有的组合；
枚举的方式就是枚举左括号 "(" 和右括号 ")" 中间可能的合法的括号对数，而剩下的合法的括号对数在与第一个左括号 "(" 配对的右括号 ")" 的后面，这就用到了以前的状态。

状态转移方程是：
dp[i] = "(" + dp[可能的括号对数] + ")" + dp[剩下的括号对数]

dp[i] = "(" + dp[j] + ")" + dp[i- j - 1] , j = 0, 1, ..., i - 1

第 3 步：思考初始状态和输出：

初始状态：因为我们需要 0 对括号这种状态，因此状态数组 dp 从 0 开始，0 个括号当然就是 [""]。
输出：dp[n] 。

vector<string> generateParenthesis(int n) {
        vector<vector<string>> list;
        vector<string> dp0;
        if(n==0) return dp0;
        dp0.push_back("");
        list.push_back(dp0);
        for(int k=1;k<=n;k++){
            vector<string> dp;
            for(int i=0;i<k;i++){
                int j=k-i-1;
                for(string str:list[i]){
                    for(string s:list[j]){
                        dp.push_back("("+str+")"+s);
                    }
                }
            }
            list.push_back(dp);
        }
        return list[n];
    }

作者：liweiwei1419
链接：https://leetcode-cn.com/problems/generate-parentheses/solution/hui-su-suan-fa-by-liweiwei1419/
来源：力扣（LeetCode）

31. 下一个排列

难度中等598

实现获取下一个排列的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。

如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。

必须原地修改，只允许使用额外常数空间。

以下是一些例子，输入位于左侧列，其相应输出位于右侧列。
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

此题不会！！！！！！！多看看

问题描述
这道题是 LeetCode 31题。
“下一个排列”的定义是：给定数字序列的字典序中下一个更大的排列。如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
我们可以将该问题形式化地描述为：给定若干个数字，将其组合为一个整数。如何将这些数字重新排列，以得到下一个更大的整数。如 123 下一个更大的数为 132。如果没有更大的整数，则输出最小的整数。
以 1,2,3,4,5,6 为例，其排列依次为：
123456
123465
123546
...
654321

可以看到有这样的关系：123456 < 123465 < 123546 < ... < 654321。
算法推导
如何得到这样的排列顺序？这是本文的重点。我们可以这样来分析：

我们希望下一个数比当前数大，这样才满足“下一个排列”的定义。因此只需要将后面的「大数」与前面的「小数」交换，就能得到一个更大的数。比如 123456，将 5 和 6 交换就能得到一个更大的数 123465。
我们还希望下一个数增加的幅度尽可能的小，这样才满足“下一个排列与当前排列紧邻“的要求。为了满足这个要求，我们需要：

在尽可能靠右的低位进行交换，需要从后向前查找
将一个尽可能小的「大数」与前面的「小数」交换。比如 123465，下一个排列应该把 5 和 4 交换而不是把 6 和 4 交换
将「大数」换到前面后，需要将「大数」后面的所有数重置为升序，升序排列就是最小的排列。以 123465 为例：首先按照上一步，交换 5 和 4，得到 123564；然后需要将 5 之后的数重置为升序，得到 123546。显然 123546 比 123564 更小，123546 就是 123465 的下一个排列

以上就是求“下一个排列”的分析过程。
算法过程
标准的“下一个排列”算法可以描述为：

从后向前查找第一个相邻升序的元素对 (i,j)，满足 A[i] < A[j]。此时 [j,end) 必然是降序
在 [j,end) 从后向前查找第一个满足 A[i] < A[k] 的 k。A[i]、A[k] 分别就是上文所说的「小数」、「大数」
将 A[i] 与 A[k] 交换
可以断定这时 [j,end) 必然是降序，逆置 [j,end)，使其升序
如果在步骤 1 找不到符合的相邻元素对，说明当前 [begin,end) 为一个降序顺序，则直接跳到步骤 4

该方法支持数据重复，且在 C++ STL 中被采用。

作者：imageslr
链接：https://leetcode-cn.com/problems/next-permutation/solution/xia-yi-ge-pai-lie-suan-fa-xiang-jie-si-lu-tui-dao-/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

public class Solution {
    public void nextPermutation(int[] nums) {
        int i = nums.length - 2;
        while (i >= 0 && nums[i + 1] <= nums[i]) {
            i--;
        }
        if (i >= 0) {
            int j = nums.length - 1;
            while (j >= 0 && nums[j] <= nums[i]) {
                j--;
            }
            swap(nums, i, j);
        }
        reverse(nums, i + 1);
    }

    private void reverse(int[] nums, int start) {
        int i = start, j = nums.length - 1;
        while (i < j) {
            swap(nums, i, j);
            i++;
            j--;
        }
    }

    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

作者：LeetCode
链接：https://leetcode-cn.com/problems/next-permutation/solution/xia-yi-ge-pai-lie-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

33. 搜索旋转排序数组

难度中等868收藏分享切换为英文关注反馈

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

示例 1:

输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4

示例 2:

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

在常规二分搜索的时候查看当前 mid 为分割位置分割出来的两个部分 [l, mid] 和 [mid + 1, r] 哪个部分是有序的，并根据有序的那个部分确定我们该如何改变二分搜索的上下界，因为我们能够根据有序的那部分判断出 target 在不在这个部分：


//题目要求用二分
class Solution {
public:
    int search(vector<int>& nums, int target) {
       int n=nums.size();
       if(n==0) return -1;
       if(n==1) return nums[0]==target?0:-1;
       int l=0,r=n-1;
       while(l<=r){
           int mid=(l+r)/2;
           if(nums[mid]==target) return mid;
           if(nums[l]<=nums[mid]){
               //说明l-mid是有序的
               if(nums[l]<=target&&target<=nums[mid]) r=mid-1;
               else l=mid+1;
           }else{
               //说明mid-r是有序的。
               if(nums[mid]<=target&&target<=nums[r]) l=mid+1;
               else r=mid-1;
           }
       }
       return -1;
    }
};

34. 在排序数组中查找元素的第一个和最后一个位置

难度中等537收藏分享切换为英文关注反馈

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

你的算法时间复杂度必须是 O(log n) 级别。

如果数组中不存在目标值，返回 [-1, -1]。

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]

示例 2:

输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]

典型二分题目

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int l=0;
        int r=nums.size()-1;
        while(l<=r){
            int mid=(l+r)/2;
            if(nums[mid]==target){
                l=mid;r=mid;
                while(l>0&&nums[l-1]==nums[l]) l--;
                while(r<nums.size()-1&&nums[r+1]==nums[r]) r++;
                return {l,r};
            }else if(nums[mid]<target){
                l=mid+1;
            }else{
                r=mid-1;
            }
        }
        return {-1,-1};
    }
};

//但其实本题是在问二分查找的边界。

不好意思以后再补。。。。

39. 组合总和

难度中等793收藏分享切换为英文关注反馈

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

所有数字（包括 target）都是正整数。
解集不能包含重复的组合。

示例 1：

输入：candidates = [2,3,6,7], target = 7,
所求解集为：
[
  [7],
  [2,2,3]
]

示例 2：

输入：candidates = [2,3,5], target = 8,
所求解集为：
[
  [2,2,2,2],
  [2,3,3],
  [3,5]
]

提示：

1 <= candidates.length <= 30
1 <= candidates[i] <= 200
candidate 中的每个元素都是独一无二的。
1 <= target <= 500

简单回溯。

class Solution {
public:
    vector<int> tmp;
    void get(int index,int sum,int target,vector<int> candidates,vector<vector<int>>& ans){
        if(sum==target){
            ans.push_back(tmp);
            return;
        }
        if(index>candidates.size()-1||sum>target) return;
        tmp.push_back(candidates[index]);
        get(index,sum+candidates[index],target,candidates,ans);
        tmp.pop_back();
        get(index+1,sum,target,candidates,ans);
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<vector<int>> ans;
        get(0,0,target,candidates,ans);
        return ans;
    }
};

神秘的义勇神驹

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode hot-100 简单and中等难度，11-20.

20. 有效的括号难度简单1746收藏分享切换为英文关注反馈给定一个只包括 '('，')'，'{'，'}'，'['，']'的字符串，判断字符串是否有效。有效字符串需满足：左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。注意空字符串可被认为是有效字符串。示例 1:输入: "()"输出: true示例2:输入: "()[]{}"输出: true示例3:输入: "(]"输出: false示例4:输入: "([)]"输...
复制链接

扫一扫

专栏目录