LeetCode详解C++版

打算把LeetCode上面的题都实现一遍，每日两题

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。

示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]

思路
巧用map结构
代码

class Solution {
   
   
public:
    vector<int> twoSum(vector<int>& nums, int target) {
   
   
        unordered_map<int, int> hamap;
        int x = -1;
        for (int i = 0; i < nums.size(); i++)
        {
   
   
            x = target - nums[i];
            if (hamap.find(x) != hamap.end())
            {
   
   
                return{
   
    hamap.find(x)->second, i };
            }
            hamap[nums[i]] = i;
        }
        return {
   
   };
    }
};

2. 两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

思路

代码

class Solution {
   
   
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
   
   
		ListNode* sumnode = new ListNode(-1);
        ListNode* head = sumnode;
        int sum=0;
        bool carry=false;
        while(l1!=NULL || l2!=NULL)
        {
   
   
            sum = 0;
            if(l1!=NULL)
            {
   
   
                sum += l1->val;
                l1 = l1->next;
                
            }
            if(l2!=NULL)
            {
   
   
                sum += l2->val;
                l2 = l2->next;
            }
            if(carry)
            {
   
   
                sum++;
            }
            head->next = new ListNode(sum%10);
            head = head->next;
            if(sum >= 10){
   
   
                carry = true;
            }else{
   
   
                carry = false;
            }
        }
        if(sum >= 10){
   
   
           head->next = new ListNode(1);
        }
        return sumnode->next;
    
    }
};

改进版

/**
 * 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* addTwoNumbers(ListNode* l1, ListNode* l2) {
   
   
		ListNode* re = new ListNode(0);
        ListNode* r = re;
        int carry=0;
        while(l1!=NULL || l2!=NULL)
        {
   
   
            int x = 0;
            int y = 0;
            if(l1!=NULL)
            {
   
   
                x = l1->val;    
            }else{
   
   
                x = 0;
            }
            if(l2!=NULL)
            {
   
   
                y = l2->val;      
            }else{
   
   
                y = 0;
            }
            int s = carry + x + y;
            carry = s/10;
            r->next = new ListNode(s%10);
            r = r->next;
            if(l1!=NULL)
            {
   
   
                l1 = l1->next;
            }
            if(l2!=NULL)
            {
   
   
                l2 = l2->next;
            }        
        }
        if(carry > 0){
   
   
           r->next = new ListNode(1);
        }
        return re->next;
    }
};

11. 盛最多水的容器

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
返回容器可以储存的最大水量。
说明：你不能倾斜容器。

示例 1：
输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
示例 2：
输入：height = [1,1]
输出：1

思路
使用双指针 注意！我们每次只要移动高度小的一边，因为移动小的那一边可能会增大，但是移动大的一边一定会减小
代码

class Solution {
   
   
public:
    int maxArea(vector<int>& height) {
   
   
        int i = 0,j = height.size()-1,res = 0;
        while(i < j){
   
   
            if(height[i]<height[j])
            {
   
   
                res = max(res,height[i]*(j-i));
                i++;
            }else{
   
   
                res = max(res,height[j]*(j-i));
                j--;
            }
           
        }
        return res;
    }
};

15.三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。

示例 1：
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
示例 2：
输入：nums = []
输出：[]
示例 3：
输入：nums = [0]
输出：[]

思路
可以使用双指针，先排序（时间复杂度nlogn），然后令L = i+1 ，R = n - 1，我们遍历i，如果值大了我们就R–，小了就L++
代码

class Solution {
   
   
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
   
   
        vector<vector<int>> ans;
        if(nums.size()<3) return ans;
        sort(nums.begin(), nums.end());
        if(nums[0]>0) return ans;
        for(int i=0;i<nums.size();i++)
        {
   
   
            if(nums[i]>0) return ans;
            if(i>0 && nums[i] == nums[i-1]) continue;     
            int left = i+1, right = nums.size()-1;
            while(left< right){
   
   
                if(nums[i] + nums[left] + nums[right] == 0)
                {
   
   
                    ans.push_back({
   
   nums[i], nums[left], nums[right]});
                    while(left<right && nums[left] == nums[left+1])
                        left++;
                    while(left<right && nums[right] == nums[right-1])
                        right--;
                    left++;
                    right--;
                }else if(nums[i] + nums[left] + nums[right] > 0) right--;
                else left++;
            }    
        }
        return ans;
    }
};

33.搜索旋转排序数组

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

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

思路
二分查找题，先用二分查找找到k，然后找到目标值
代码

class Solution {
   
   
public:
    int search(vector<int>& nums, int target) {
   
   
        if(nums.empty()) return -1;
        int n = nums.size(),r = n-1,l = 0;
        // find k
        while(l<r)
        {
   
   
            int m = l + (r -l)/2;
            if(nums[m] < nums[r]) r = m;