大部分为抄答案，看解析，且跳过困难的题目，希望能学到点东西

242. 有效的字母异位词 还是两个哈希表，不过我把它弄成了一个

243. 同构字符串 两个哈希表，还不错啦；

244. 对称二叉树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
bool compare(struct TreeNode* left, struct TreeNode* right) {
    if ((left == NULL && right != NULL)
        || (left != NULL && right == NULL)) {   /* 单个节点为空，匹配失败 */
            return false;
    } else if (left == NULL && right == NULL) { /* 都为空，匹配成功 */
        return true;
    } else if (left->val != right->val) {   /* 都不为空，节点值不相同，匹配失败 */
        return false;
    }
    /* 运行到此表示当前节点不为空，且节点值相等，开始递归 */
    bool outside    = compare(left->left, right->right);
    bool inside     = compare(left->right, right->left);
    /* 返回递归结果 */
    return outside && inside;
}

bool isSymmetric(struct TreeNode* root){
    /* 根节点为空，则对称 */
    if (root == NULL) {
        return true;
    }
    /* 递归判断 */
    return compare(root->left, root->right);
}

1. 相同的树 蛮顺利的

2. 合并两个有序链表

大佬递归确实强

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

//根节点写的不太顺利，但做出来了
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
    struct ListNode *use;
    // struct ListNode root;
    struct ListNode* root = (struct ListNode*)malloc(sizeof(struct ListNode));
    // root = list2;
    // use = root->next;
    root->next = NULL;
    use = root;
    int temp = 0;
    while (list1 || list2) {
        if (!list1) { // list1 null
            use->next = list2;
            list2 = list2->next;
            use = use->next;
        } else if (!list2) { // list2 null
            use->next = list1;
            list1 = list1->next;
            use = use->next;
        } else { // compare
            if (list1->val < list2->val) {
                use->next = list1;
                list1 = list1->next;
                use = use->next;
            } else {
                use->next = list2;
                list2 = list2->next;
                use = use->next;
            }
        }
    }
    return root->next;
}


struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
    if (list1 == NULL) {
        return list2;
    }
    if (list2 == NULL) {
        return list1;
    }
    
    struct ListNode* mergedList;
    
    if (list1->val <= list2->val) {
        mergedList = list1;
        mergedList->next = mergeTwoLists(list1->next, list2);
    } else {
        mergedList = list2;
        mergedList->next = mergeTwoLists(list1, list2->next);
    }
    
    return mergedList;
}

作者：tt-1103
链接：https://leetcode.cn/problems/merge-two-sorted-lists/solutions/2512813/he-bing-you-xu-lian-biao-by-tt-1103-74r9/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

2. 两数相加

// 链表递归 https://leetcode.cn/problems/add-two-numbers/description/
struct ListNode *helper(struct ListNode *l1, struct ListNode *l2, int carry)
{
    if (l1 == NULL && l2 == NULL && carry == 0)
    {
        return NULL;
    }

    int sum = carry;
    if (l1 != NULL)
    {
        sum += l1->val;
        l1 = l1->next;
    }
    if (l2 != NULL)
    {
        sum += l2->val;
        l2 = l2->next;
    }

    struct ListNode *l = malloc(sizeof(struct ListNode));
    l->val = sum % 10;
    l->next = helper(l1, l2, sum / 10);

    return l;
}

struct ListNode *addTwoNumbers(struct ListNode *l1, struct ListNode *l2)
{
    return helper(l1, l2, 0);
}

20. 有效的括号 大佬的答案

bool isValid(char* s) {
    char mp[128] = {};
    mp[')'] = '(';
    mp[']'] = '[';
    mp['}'] = '{';

    int top = 0; // 直接把 s 当作栈
    for (int i = 0; s[i]; i++) {
        char c = s[i];
        if (mp[c] == 0) {                           // c 是左括号
            s[top++] = c;                           // 入栈
        } else if (top == 0 || s[--top] != mp[c]) { // c 是右括号
            return false; // 没有左括号，或者左括号类型不对
        }
    }
    return top == 0; // 所有左括号必须匹配完毕
}

15. 三数之和

能猜到双指针我就很知足了，

48. 旋转图像

难点在原地

看答案，找规律，转置+翻转，完成

void rotate(int** matrix, int matrixSize, int* matrixColSize) {

    int temp;

    // 转置

    for (int i = 0; i < matrixSize; i++) {

        for (int j = i + 1; j < matrixSize; j++) {

            temp = matrix[i][j];

            matrix[i][j] = matrix[j][i];

            matrix[j][i] = temp;

        }

    }

    // 翻转

    for (int i = 0; i < matrixSize; i++) { // 行

        for (int j = 0; j < matrixSize/2; j++) { //列

            temp = matrix[i][j];

            matrix[i][j] = matrix[i][matrixSize-j-1];

            matrix[i][matrixSize-j-1] = temp;

        }

    }

}

238. 除自身以外数组的乘积（做出了，但耗时，再做）

380. O(1) 时间插入、删除和获取随机元素（再看看吧） 45. 跳跃游戏 II（再做）

55. 跳跃游戏（想耍小聪明降低运算时间，但是各种漏洞）

int removeDuplicates(int* nums, int numsSize) {

if (numsSize <= 2) {

return numsSize;

}

int slow = 2, fast = 2;

while (fast < numsSize) {

if (nums[slow - 2] != nums[fast]) {

nums[slow] = nums[fast];

++slow;

}

++fast;

}

return slow;

}

class LRUCache {
public:
    LRUCache (int capacity) {
        __cap = capacity;
    }
    
    int get (int key) {
        //key = 0;
        if (hashmap.find (key) == hashmap.end ()){ // 没找到
            return -1;
        } else {
                        // 添加
            key_value kv;
            kv.key = key;
            kv.value = hashmap [key]->value;



            value_list.erase (hashmap [key]);
            value_list.push_front (kv);
            hashmap [key] = value_list.begin ();
            return kv.value;
        }
        return key;
    }
    
    void put (int key, int value) {
        if (hashmap.find (key) == hashmap.end ()){ // 没找到
            // 满了吗？

            if (__cap == hashmap.size ()){
                hashmap.erase ( value_list.back ().key);
                value_list.pop_back ();
            }
            // 添加
            key_value kv;
            kv.key = key;
            kv.value = value;
            value_list.push_front ( kv);
            hashmap [key] = value_list.begin ();




        } else { // 找到了
            // 删除并添加到头

            value_list.erase (hashmap [key]);
            // 添加
            key_value kv;
            kv.key = key;
            kv.value = value;
            value_list.push_front ( kv);
            hashmap [key] = value_list.begin ();

        }
    }
private:
    int __cap;
    struct key_value {
        int key;
        int value;
        bool operator==(const key_value& kv){
            return key == kv.key;
        }
    };
    map<int, list<key_value>::iterator> hashmap;
    list<key_value> value_list;

};

#include <iostream>
#include <unordered_map>
#include <list>

class LRUCache {
public:
    LRUCache (int capacity) : capacity (capacity) {
    }

    int get (int key) {
        if (cache_map.find (key) == cache_map.end ()) {
            return -1; // 未找到
        } else {
            // 将键值对移到链表头部表示最近使用
            moveToFront (key);
            return cache_map [key]->second;
        }
    }

    void put (int key, int value) {
        if (cache_map.find (key) == cache_map.end ()) {
            if (cache_map.size () >= capacity) {
                // 缓存已满，删除最久未使用的项目
                int lru_key = lru_list.back ().first;
                cache_map.erase (lru_key);
                lru_list.pop_back ();
            }
            // 添加新项目到链表头部
            lru_list.push_front (std::make_pair (key, value));
            cache_map [key] = lru_list.begin ();
        } else {
            // 更新已存在的键值对的值，然后移到链表头部表示最近使用
            cache_map [key]->second = value;
            moveToFront (key);
        }
    }

private:
    int capacity;
    std::unordered_map<int, std::list<std::pair<int, int>>::iterator> cache_map;
    std::list<std::pair<int, int>> lru_list;

    // 将键值对移到链表头部
    void moveToFront (int key) {
        auto it = cache_map [key];
        lru_list.splice (lru_list.begin (), lru_list, it);
        cache_map [key] = lru_list.begin ();
    }
};

/
 * 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* reverseList(ListNode* head) {
        if (head == NULL || head->next == NULL) {
            return head;
        }
        ListNode* ret = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return ret;
    }
};

int lengthOfLongestSubstring(string s)
{
    string temp;
    int ftemp = 0;
    for(int i = s.length(); i > 0; i--)
    {
        if (temp.find(s[s.length() - i]) > temp.length()) // 无重复  temp.find(s[s.length() - i]) == -1 但会很大 所以
        {
            // 无重复
            temp.push_back(s[s.length() - i]);
            ftemp = temp.length() > ftemp ? temp.length() : ftemp;
        }
        else
        {
            // 有重复
            i += (temp.length() - temp.find(s[s.length() - i]) - 1);
            temp.clear();
            temp.push_back(s[s.length() - i]);
            ftemp = temp.length() > ftemp ? temp.length() : ftemp;
        }
    }
    return ftemp;
}

string::find(char c) // 返回c在string中的位置 无则返回string::npos
string::length() // 返回string的长度
string::push_back(char c) // 在string的末尾添加c
string::clear() // 清空string