leetcode 笔记day1

• day1
  • LeetCode1:两数之和（难度：简单）
  • leetcode2:两数相加（链表，中等）

1.LeetCode1:两数之和 (简单)
题目描述：
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

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

示例:

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

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

以下两种解题思路来自：LeetCode官方讲解，作者在此做记录以便后续的复习。

解法1：
暴力法，遍历每个元素 x，并查找是否存在一个值与 target−x 相等的目标元素。

代码：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        //1.暴力法,遍历每个元素 x，并查找是否存在一个值与 target−x 相等的目标元素。
        vector<int> res;
        for(int i=0;i<nums.size()-1;i++)
        {
            for(int j=i+1;j<nums.size();j++)
            {
                if(nums[j]==target-nums[i])
                {
                    res.push_back(i);
                    res.push_back(j);
                    break;
                }
            }
        }
        return res;
    }
};

复杂度分析：

• 时间复杂度：O(n²)
  对于每个元素，我们试图通过遍历数组的其余部分来寻找它所对应的目标元素，这将耗费 O(n)的时间。因此时间复杂度为 O(n²)。
• 空间复杂度：O(1)。

解法2：哈希表，一次哈希,将数组中的元素放入哈希表中，查找target-nums是否已经在哈希表中，若是在，则返回数组下标

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        //hash法
        unordered_map<int,int> m;//<key=target-nums[i],value= index>
        for(int i=0;i<nums.size();i++)
        {
            int temp =target-nums[i];
            if(m.find(temp)!=m.end())//存在一个值与target-nums[i]相等的值
            {
                return {m[temp],i};
            }
            m[nums[i]]=i;
        }
        return {};
    }
};

复杂度分析：

• 时间复杂度：O(n)，
  我们只遍历了包含有 n 个元素的列表一次。在表中进行的每次查找只花费 O(1) 的时间。
• 空间复杂度：O(n)，
  所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储 n个元素。

Tip 1：为什么用unordered_map而不是map？

采用unordered_map而不是map的原因在于，unordered_map的底层实现是hash表，是无序的。map的底层实现是红黑树（非严格平衡二叉搜索树），是有序的。本题不需要对其进行排序，所以使用unordered_map。

Tip2：unordered_map的元素查找

1. 使用count，返回的是被查找元素的个数。如果有，返回1；否则，返回0。注意，map中不存在相同元素，所以返回值只能是1或0。
2. 使用find，返回的是被查找元素的位置，没有则返回map.end()。

例：

map<string,int>::iterator it;
it=test.find("test0");
cout<<"test0 find:";
if(it==test.end()){
	cout<<"test0 not found"<<endl;
}else{
	cout<<it->second<<endl;
}

2. leetcode2:两数之和（链表，中等）

题目描述：
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字0之外，这两个数都不会以0开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

思路：

1. 定义一个结点作为结果链表的头
2. 定义两个指针p1，p2分别指向两个待相加链表的头，一个指针cur指向当前结点，一个变量carry记录每次的进位，当和sum大于10时，carry=1否则 carry=0
3. 从头遍历两个链表，依次求和，求和时注意要将进位考虑进取，直到两个链表都遍历结束
4. 若最高位的进位为1，则创建新结点，赋值为1，将其添加到结果链表中。

代码如下:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* newHead= new ListNode(0);
        ListNode* p1=l1,*p2=l2,*cur = newHead;
        int carry =0;//进位
        while(p1!=NULL || p2!=NULL)  //注：这里是或的关系
        {
            //当其中一个结点为NULL时，则将值赋值为0
            int x = (p1!=NULL)?p1->val:0; 
            int y = (p2!=NULL)?p2->val:0;
            //求和
            int sum = x+y+carry;
            //求进位
            carry = sum/10;
            //将结果加入到结果链表中，cur后移一位
            cur->next=new ListNode(sum%10);
            cur=cur->next;
            if(p1!=NULL){
                p1=p1->next;
            } 
            if(p2!=NULL){
                p2=p2->next;
            }
        }
        if(carry==1)//最高位存在进位，将1加入到结果链表的末尾处
        {
            cur->next = new ListNode(carry);
        }
        return newHead->next;
    }
};