Leetcode解题记录

Posted 2021-03-03 钢印

1.两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

 

解：

 1 class Solution {
 2 public:
 3     vector<int> twoSum(vector<int>& nums, int target) {
 4         int start=0;
 5         int next=1;
 6         vector<int> results;
 7         while(start<nums.size()){
 8             if(nums.at(start)>target){
 9                 start++;
10             }
11             else{
12                 int submit=target-nums.at(start);
13                 while(next<(nums.size()-start)){
14                     if(nums.at(start+next)!=submit){
15                         next++;
16                     }
17                     else{
18                         results.push_back(start);
19                         results.push_back(start+next);
20                         return results;
21                     }
22                 }
23             }
24         }
25         return results;
26     }
27 };

在得到最后的结果前遇到两个编译错误：Reference to non-static member function be called和control may reach end of non-void function。

第一个检查一下调用的类的函数名有没有写正确，我把nums.size()写成nums.size。所以编译出错。

第二个是跟返回类型不匹配相关的。

 

代码提交之后只通过了一个测试案例，检查之后在23行新增 start++；再次提交通过23个案例！

输入： [-1,-2,-3,-4,-5]
-8

输出： []

预期： [2,4]

关键问题出在第8行的判据：nums.at(start)>target。对于负数来说总是为真，所以输出为空！

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> results;
        int start=0;
        while(start<nums.size()){
            for(int next=1;next<(nums.size()-start);next++){
                if(nums.at(start)+nums.at(start+next)==target){
                    results.push_back(start);
                    results.push_back(start+next);
                    return results;
                }
            }
            start++;
        }
        return results;
    }
};

结果的耗时太长！！！

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> results;
        map<int,int> mymap;
        for(int i=0;i<nums.size();i++){
            mymap[nums[i]]=i;
        }
        for(int i=0;i<nums.size();i++){
            int submit=target-nums.at(i);
            if(mymap.count(submit)&&mymap[submit]!=i){
                results.push_back(i);
                results.push_back(mymap[submit]);
                return results;
            }
        }
        return results;
    }
};

使用map类之后：

2.搜索插入位置。

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

本题带给我的思考——一般二分查找是直接找目标值，而本题需要返回边界的索引值！！！

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

 3.删除链表的倒数第N个节点

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        int length=0;
        ListNode* temp=head;
        ListNode* res=head;
        while(head!=NULL){
            length++;
            head=head->next;
        }
        if(length==n)
            return res->next;
        while(length-n-1>0){
            temp=temp->next;
            length--;
        }
        temp->next=temp->next->next;
        return res;
    }
};

 

 4.两两交换链表中的节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head==NULL||head->next==NULL)
            return head;
        ListNode* temp=head;
        int v;
        while(temp!=NULL&&temp->next!=NULL){
            v=temp->val;
            temp->val=temp->next->val;
            temp->next->val=v;
            temp=temp->next->next;
        }
        return head;
    }
};

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

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int left=0;
        int right=nums.size()-1;
        int start,end;
        vector<int> res;
        if(nums.size()==0){
            res={-1,-1};
            return res;
        }
        if(nums.size()==1){
            if(target==nums[0])
                res={0,0};
            else
                res={-1,-1};
            return res;
        }
        while(left<right){
            int mid=left+(right-left)/2;
            if(nums[mid]<target)
                left=mid+1;
            else
                right=mid;//这里一定是right=mid，不然区间判定会出错！！！！
        }
        start=end=left;
        if(nums[start]!=target){
            res={-1,-1};
            return res;
        }
        int i=start;
        while(i<nums.size()&&nums[i]==target){
            end=i;
            i++;
        }
        res.push_back(start);
        res.push_back(end);
        return res;
    }
};