[TOC]

两数之和

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

思路：Hash存储降低复杂度，实现容易高效实现

class Solution {
    func twoSum(_ nums: [Int], _ target: Int) -> [Int] {

        var keys:[Int:Int] = [Int:Int]()
        
        for index in 0..<nums.count {
            let item = nums[index]

            let replace = target - item
            if let result = keys[replace] {
                return [result,index]
            }
            keys[item] = index
        }
        return []
    }
}

两数相加

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

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

思路： 遍历链表满10 记录1 然后进1

class Solution {

        func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
    let prev = ListNode.init(0)
    var carry = 0
    
    var cur:ListNode? = prev
    
    var templ1 = l1
    var templ2 = l2
    
    while templ1 != nil || templ2 != nil {
        let x = templ1?.val ?? 0
        let y = templ2?.val ?? 0
        var sum = x + y + carry
        carry = sum > 9 ? 1:0
        sum = sum%10
        cur?.next = ListNode.init(sum)
        cur = cur?.next
        if templ1 != nil {
            templ1 = templ1?.next
        }
        if templ2 != nil {
            templ2 = templ2?.next
        }
    }
    if(carry == 1){
        cur?.next = ListNode.init(carry);
    }
    return prev.next
        }
}

无重复字符的最长子串

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度

输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

思路：记录每个字符串所在位置当字典存起来如果查到重复的则当前为不重复字符串

class Solution {
    func lengthOfLongestSubstring(_ s: String) -> Int {
        
        var start = -1
        var len = 0
        var tmpHash:[Character:Int] = [Character:Int]()
          for i in 0..<s.count {

            let index = tmpHash[s[String.Index.init(encodedOffset: i)]]
            tmpHash[s[String.Index.init(encodedOffset: i)]] = i

            if index != nil,index! > start {
                start = index!
            }
            let tlen = i - start
            if tlen > len  {
                len = tlen
            }
        }
        return len
    }

}

let test = Solution()
print(test.lengthOfLongestSubstring("abae"))

寻找两个正序数组的中位数

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

思路： 了解中位数概念即可

class Solution {
    func findMedianSortedArrays(_ nums1: [Int], _ nums2: [Int]) -> Double {
        var arr:[Int] = nums1
        arr.append(contentsOf: nums2)
        
        arr = arr.sorted { l1, r1 in
            return l1 < r1
        }
        if arr.count%2 == 0 {
            let center = arr.count/2
            let left = Double(arr[center - 1])
            let right =  Double(arr[center])
            return (left + right) * 0.5
        }
        else {
            return Double(arr[Int((arr.count - 1)/2)])
        }
    }
}

最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。

思路： 遍历然后从中间向两边开花

class Solution {
public:
    string longestPalindrome(string s) {
 int n = s.size();
        int start = 0, end = 0;
        for (int i = 0; i < 2 * n - 1; i++) {
            int l = i / 2, r = i / 2 + i % 2;
            while (l >= 0 && r < n && s[l] == s[r]) {
                if (r - l > end - start) {
                    start = l;
                    end = r;
                }
                l--;
                r++;
            }    
        }
        return s.substr(start, end - start + 1);
    }
};