目录

1. Two Sum  （https://leetcode.com/problems/two-sum/）

2.Add Two Numbers  (https://leetcode.com/problems/add-two-numbers/)

3.Longest Substring Without Repeating Characters（https://leetcode.com/problems/longest-substring-without-repeating-characters/）

4.Maximum Subarray  (https://leetcode.com/problems/maximum-subarray/)

5.Single Number （https://leetcode.com/problems/single-number/）

6.Path Sum(https://leetcode.com/problems/path-sum/)

---

leetcode题，每天刷一刷。当然更多的是抄袭原本答案，然后学习一下。

网址：https://leetcode.com/problemset/all/?page=1

1. Two Sum  （https://leetcode.com/problems/two-sum/）

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Example 1:

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Output: Because nums[0] + nums[1] == 9, we return [0, 1].

Example 2:

Input: nums = [3,2,4], target = 6
Output: [1,2]

Example 3:

Input: nums = [3,3], target = 6
Output: [0,1]

思路：

方法 1：暴力，复杂度 O(n 2 )，会超时

方法 2：hash。用一个哈希表，存储每个数对应的下标，复杂度 O(n).

方法 3：先排序，然后左右夹逼，排序 O(n log n)，左右夹逼 O(n)，最终 O(n log n)。但是注意， 这题需要返回的是下标，而不是数字本身，因此这个方法行不通。

答案：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        map<int,int> mapping;
        vector<int> result;
        for(int i = 0; i < nums.size(); i++){
            mapping[nums[i]] = i;
        }
        
        for(int i = 0; i < nums.size(); i++){
            int value = target - nums[i];
            if(mapping.find(value) != mapping.end() && mapping[value] > i){
                result.push_back(i);
                result.push_back(mapping[value]);
                break;
            }
        }
        return result;
    }
};

2.Add Two Numbers  (https://leetcode.com/problems/add-two-numbers/)

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Example 1:

Input: l1 = [2,4,3], l2 = [5,6,4]
Output: [7,0,8]
Explanation: 342 + 465 = 807.

Example 2:

Input: l1 = [0], l2 = [0]
Output: [0]

Example 3:

Input: l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
Output: [8,9,9,9,0,0,0,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:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode dummy(-1); //头节点
        int carry = 0;
        ListNode *pre=&dummy;      
        for(ListNode *pa = l1, *pb = l2;
            pa != nullptr || pb != nullptr;
            pa = pa == nullptr ? nullptr : pa->next,
            pb = pb == nullptr ? nullptr : pb->next,
            pre = pre->next){
            const int ai = pa == nullptr ? 0 : pa->val;
            const int bi = pb == nullptr ? 0 : pb->val;
            const int value = (ai + bi + carry)%10;
            carry = (ai + bi + carry)/10;
            pre->next = new ListNode(value);      
        }
        
        if(carry > 0){
            pre->next = new ListNode(carry); 
        }
        return dummy.next;
    }
};

3.Longest Substring Without Repeating Characters（https://leetcode.com/problems/longest-substring-without-repeating-characters/）

Given a string s, find the length of the longest substring without repeating characters.

Example 1:

Input: s = "abcabcbb"
Output: 3
Explanation: The answer is "abc", with the length of 3.

Example 2:

Input: s = "bbbbb"
Output: 1
Explanation: The answer is "b", with the length of 1.

Example 3:

Input: s = "pwwkew"
Output: 3
Explanation: The answer is "wke", with the length of 3.
Notice that the answer must be a substring, "pwke" is a subsequence and not a substring.

Example 4:

Input: s = ""
Output: 0

分析：

代码：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        const int ASCII_MAX=26;
        int last[ASCII_MAX]; //记录字符上次出现过的位置
        int start = 0; //记录当前子串的起始位置
        
        fill(last, last + ASCII_MAX, -1); //0也是有效位置，因此初始化为-1
        int max_len = 0;
        
        for(int i = 0; i < s.size(); i++) {
            if(last[s[i] - 'a'] >= start) {
                max_len = max(i - start, max_len);
                start = last[s[i] - 'a'] +1;
            }
            last[s[i] - 'a'] = i;
        }
        return max((int)s.size() - start,max_len);
    }
};

4.Maximum Subarray  (https://leetcode.com/problems/maximum-subarray/)

Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.

A subarray is a contiguous part of an array.

Example 1:

Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
Output: 6
Explanation: [4,-1,2,1] has the largest sum = 6.

Example 2:

Input: nums = [1]
Output: 1

Example 3:

Input: nums = [5,4,-1,7,8]
Output: 23

分析：

 答案：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int result = INT_MIN, f=0;
        for(int i = 0; i< nums.size(); i++){
            f = max(f+nums[i],nums[i]);
            result = max(f,result);
        }
        
        return result;
    }
};

5.Single Number （https://leetcode.com/problems/single-number/）

Given a non-empty array of integers nums, every element appears twice except for one. Find that single one.

You must implement a solution with a linear runtime complexity and use only constant extra space.

Example 1:

Input: nums = [2,2,1]
Output: 1

Example 2:

Input: nums = [4,1,2,1,2]
Output: 4

Example 3:

Input: nums = [1]
Output: 1

分析：按位异或运算符(^)
        按位异或运算将两个运算分量的对应位按位遵照以下规则进行计算：
          0 ^ 0 = 0, 0 ^ 1 = 1, 1 ^ 0 = 1, 1 ^ 1 = 0
即相应位的值相同的，结果为 0，不相同的结果为 1。

代码：

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int x = 0;
        for(int i = 0; i < nums.size(); i++){
            x ^= nums[i];
        }
        
        return x;
    }
};

6.Path Sum(https://leetcode.com/problems/path-sum/)

Given the root of a binary tree and an integer targetSum, return true if the tree has a root-to-leaf path such that adding up all the values along the path equals targetSum.

A leaf is a node with no children.

Example 1:

Input: root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
Output: true

Example 2:

Input: root = [1,2,3], targetSum = 5
Output: false

Example 3:

Input: root = [1,2], targetSum = 0
Output: false

分析：

代码：

/**
 * 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:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == nullptr) return false;
        if(root->left == nullptr && root->right == nullptr)
            return targetSum == root->val;
        return hasPathSum(root->left,targetSum - root->val) ||  hasPathSum(root->right,targetSum - root->val);
    }
};