1
/**
2
 * Definition for a binary tree node.
3
 * struct TreeNode {
4
 *     int val;
5
 *     struct TreeNode *left;
6
 *     struct TreeNode *right;
7
 * };
8
 */
9
bool compare(struct TreeNode* left, struct TreeNode* right) {
10
    if ((left == NULL && right != NULL)
11
        || (left != NULL && right == NULL)) {   /* 单个节点为空，匹配失败 */
12
            return false;
13
    } else if (left == NULL && right == NULL) { /* 都为空，匹配成功 */
14
        return true;
15
    } else if (left->val != right->val) {   /* 都不为空，节点值不相同，匹配失败 */
16
        return false;
17
    }
18
    /* 运行到此表示当前节点不为空，且节点值相等，开始递归 */
19
    bool outside    = compare(left->left, right->right);
20
    bool inside     = compare(left->right, right->left);
21
    /* 返回递归结果 */
22
    return outside && inside;
23
}
24

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

1
大佬递归确实强
2

3
/**
4
 * Definition for singly-linked list.
5
 * struct ListNode {
6
 *     int val;
7
 *     struct ListNode *next;
8
 * };
9
 */
10

11
//根节点写的不太顺利，但做出来了
12
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
13
    struct ListNode *use;
14
    // struct ListNode root;
15
    struct ListNode* root = (struct ListNode*)malloc(sizeof(struct ListNode));
16
    // root = list2;
17
    // use = root->next;
18
    root->next = NULL;
19
    use = root;
20
    int temp = 0;
21
    while (list1 || list2) {
22
        if (!list1) { // list1 null
23
            use->next = list2;
24
            list2 = list2->next;
25
            use = use->next;
26
        } else if (!list2) { // list2 null
27
            use->next = list1;
28
            list1 = list1->next;
29
            use = use->next;
30
        } else { // compare
31
            if (list1->val < list2->val) {
32
                use->next = list1;
33
                list1 = list1->next;
34
                use = use->next;
35
            } else {
36
                use->next = list2;
37
                list2 = list2->next;
38
                use = use->next;
39
            }
40
        }
41
    }
42
    return root->next;
43
}
44

45

46
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
47
    if (list1 == NULL) {
48
        return list2;
49
    }
50
    if (list2 == NULL) {
51
        return list1;
52
    }
53

54
    struct ListNode* mergedList;
55

56
    if (list1->val <= list2->val) {
57
        mergedList = list1;
58
        mergedList->next = mergeTwoLists(list1->next, list2);
59
    } else {
60
        mergedList = list2;
61
        mergedList->next = mergeTwoLists(list1, list2->next);
62
    }
63

64
    return mergedList;
65
}
66

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

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

9
    int sum = carry;
10
    if (l1 != NULL)
11
    {
12
        sum += l1->val;
13
        l1 = l1->next;
14
    }
15
    if (l2 != NULL)
16
    {
17
        sum += l2->val;
18
        l2 = l2->next;
19
    }
20

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

25
    return l;
26
}
27

28
struct ListNode *addTwoNumbers(struct ListNode *l1, struct ListNode *l2)
29
{
30
    return helper(l1, l2, 0);
31
}

1
bool isValid(char* s) {
2
    char mp[128] = {};
3
    mp[')'] = '(';
4
    mp[']'] = '[';
5
    mp['}'] = '{';
6

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

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

3
    int temp;
4

5
    // 转置
6

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

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

11
            temp = matrix[i][j];
12

13
            matrix[i][j] = matrix[j][i];
14

15
            matrix[j][i] = temp;
16

17
        }
18

19
    }
20

21
    // 翻转
22

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

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

27
            temp = matrix[i][j];
28

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

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

33
        }
34

35
    }
36

37
}