LeetCode刷题Day1

LeetCode刷题Day1

88.合并两个有序数组

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意： 最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

示例 1：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。

示例 2：

输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。

示例 3：

输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

提示：

• nums1.length == m + n
• nums2.length == n
• 0 <= m, n <= 200
• 1 <= m + n <= 200
• -109 <= nums1[i], nums2[j] <= 109

进阶： 你可以设计实现一个时间复杂度为 O(m + n) 的算法解决此问题吗？

解决思路

本题可以以T(n) = O(m+n) 且 S(n) = O(1) 的开销完成，思路是：以辅助数组的方式完成是出于避免数据覆盖的考虑，而num1的后n个位置都是空的，如果从后向前遍历，将两数组中最大的先填在后面则可以避免数据覆盖。

详细代码

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        vector<int> vec;
        int i=0,j=0;
        while(i<m&&j<n){
            if(nums1[i]<nums2[j]){
                vec.push_back(nums1[i]);
                i++;
            }else{
                vec.push_back(nums2[j]);
                j++;
            }
        }
        if(i==m){
            for(int a = j;a<n;a++){
                vec.push_back(nums2[a]);
            }
        }else{
            for(int a = i;a<m;a++){
                vec.push_back(nums1[a]);
            }
        }
        nums1 = vec;
    }
};

707.设计链表

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

• MyLinkedList() 初始化 MyLinkedList 对象。
• int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
• void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
• void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
• void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
• void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

示例：

输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 3

提示：

• 0 <= index, val <= 1000
• 请不要使用内置的 LinkedList 库。
• 调用 get、addAtHead、addAtTail、addAtIndex 和 deleteAtIndex 的次数不超过 2000 。

几个需要注意的问题

• 一个不那么重要的问题：私有变量的命名规范：下划线前缀，如_dummyHead
• 第二个十分重要的问题是容量大小size和访问下标index之间的关系：
  • 一方面，size是整个链表的元素数，而index则是（本题下标从0开始）一个位置
  • 另一方面，考虑从这样一个边界问题入手：当size为0时无元素，是不允许访问的，而且能够访问的最小的下标是0，最大的下标是size-1（除了size为0时）
  • 所以得出size与index存在差1的关系，由此界定index>size-1这一非法访问边界值

详细代码

class MyLinkedList {
public:
    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val),next(nullptr){}
    };
    MyLinkedList() {
        dummyHead = new LinkedNode(0);
        len = 0;
    }
    
    int get(int index) {
        if(index>(len-1)||index<0) return -1;
        LinkedNode* p = dummyHead->next;
        for(int i=0;i<index;i++)    p=p->next;
        return p->val;
    }
    
    void addAtHead(int val) {
        LinkedNode* s = new LinkedNode(val);
        s->next = dummyHead->next;
        dummyHead->next = s;
        ++len;
    }
    
    void addAtTail(int val) {
        LinkedNode* p = dummyHead;
        LinkedNode* s = new LinkedNode(val);
        while(p->next!=nullptr) p=p->next;
        p->next = s;
        ++len;
    }
    
    void addAtIndex(int index, int val) {
        if(index>=0&&index<=len){
            LinkedNode* p = dummyHead;
            LinkedNode* s = new LinkedNode(val);
            for(int i=0;i<index;i++) p=p->next;
            s->next = p->next;
            p->next = s;
            ++len;
        }
    }
    
    void deleteAtIndex(int index) {
        if(index>=0&&index<len){
            LinkedNode* p = dummyHead;
            LinkedNode* q = p->next;
            for(int i=0;i<index;i++){
                p=p->next;
                q=q->next;
            }
            p->next = q->next;
            delete q;
            --len;
        }
    }
private:
    LinkedNode* dummyHead;
    int len;
};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */

242.有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的 字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

提示:

• 1 <= s.length, t.length <= 5 * 104
• s 和 t 仅包含小写字母

进阶: 如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？

几个注意的问题

• 对于“曾经出现过的内容，要再去找到他”的问题一般首选哈希
• 本题可以使用数组法进行哈希：因为每个输入内容都是小写字母，所以可以映射到一个大小为26的数组里面，并且无需记忆ASCII码值，只要用s[i] - 'a'做相对变换即可，虽然可以达到O(1)的空间复杂度与O(n)的时间复杂度，但是只能用来解决连续编码型问题
• 对于离散编码（如本题的进阶内容：字符串包含Unicode）则还是要使用STL中的map来解决，但会造成O(n)的空间复杂度与O(nlogn)的时间复杂度

详细代码

class Solution {
public:
    bool isAnagram(string s, string t) {
        int alphabet[26] = {0};
        int s_size = s.size(),t_size = t.size();
        for(int i=0;i<s_size;i++)   alphabet[s[i] - 'a']++;
        for(int i=0;i<t_size;i++)   alphabet[t[i] - 'a']--;
        for(int i=0;i<26;i++)
            if(alphabet[i])
                return false;
        return true;
    }
};

这里也给大家贴出STL方法解决的代码

class Solution {
public:
    bool isAnagram(string s, string t) {
        map<char,int> m;
        int size_s = s.size();
        for(int i=0;i<size_s;i++){
            m[s[i]]++;
        }
        int size_t = t.size();
        for(int i=0;i<size_t;i++){
            if(m.find(t[i]) == m.end()) return false;
            else{
                if(m[t[i]] == 0)    return false;
                else    --m[t[i]];
            }
        }
        for(int i=0;i<size_s;i++){
            if(m[s[i]]!=0)  return false;
        }
        return true;
    }
};