LeetCode Hot 100 刷题笔记（C 语言版）1-21 | 极客日志

C算法

LeetCode Hot 100 刷题笔记（C 语言版）1-21

本文整理了 LeetCode Hot 100 系列中部分题目（编号 1-21 左右）的 C 语言解法。涵盖数组、链表、树、栈及位运算等数据结构与算法。内容包括两数之和、有效括号、合并链表、爬楼梯、二叉树遍历与深度、股票买卖、只出现一次的数字、环形链表、多数元素、回文链表等经典问题。针对每道题提供了问题分析、多种解题思路（如暴力枚举、哈希表、递归、双指针）及完整的 C 语言代码实现，旨在帮助读者巩固 C 语言基础并提升算法思维能力。

日志猎手发布于 2026/3/280 浏览

1.两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。

分析：经典入门题，难度不高。直接暴力双循环解决，也有用哈希表来做的。

int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    int *a = (int*)malloc(sizeof(int)*2);
    int i, j;
    for(i=0; i<numsSize; i++){
        for(j=i+1; j<numsSize; j++){
            if(nums[i]+nums[j]==target) {
                a[0]=i;
                a[1]=j;
                *returnSize=2;
                return a;
            }
        }
    }
    return NULL;
}

20.有效的括号

给定一个只包括 '('，)，'{'，'}'，'['，] 的字符串 s，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

分析：很经典的堆栈问题，主要是判断下标 top 是否为 0。

bool isValid(char* s) {
    char stack[10001];
    int top=0;
    ( i=; s[i]!=; i++) {
         c=s[i];
         (c ==  || c ==  || c == ) {
            [++top] = c;
        }  {
            (top==){ ;}
             topChar = [top];
             ((c ==  && topChar != ) || (c ==  && topChar != ) || (c ==  && topChar != )) {
                 ;
            }
            top--;
        }
    }
    (top!=){ ;}
     ;
}

极客日志微信公众号二维码

更多推荐文章

相关免费在线工具

加密/解密文本
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。在线工具，加密/解密文本在线工具，online
Base64 字符串编码/解码
将字符串编码和解码为其 Base64 格式表示形式即可。在线工具，Base64 字符串编码/解码在线工具，online
Base64 文件转换器
将字符串、文件或图像转换为其 Base64 表示形式。在线工具，Base64 文件转换器在线工具，online
Markdown 转 HTML
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML 转 Markdown 互为补充。在线工具，Markdown 转 HTML在线工具，online
HTML 转 Markdown
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。在线工具，HTML 转 Markdown在线工具，online
JSON 压缩
通过删除不必要的空白来缩小和压缩JSON。在线工具，JSON 压缩在线工具，online

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
    struct ListNode dummy;
    struct ListNode *p=&dummy;
    while(list1!=NULL && list2!=NULL) {
        if(list1->val<=list2->val) {
            p->next=list1;
            list1=list1->next;
        } else {
            p->next=list2;
            list2=list2->next;
        }
        p=p->next;
    }
    p->next=list1?list1:list2;
    return dummy.next;
}

int climbStairs(int n) {
    if (n <= 2) return n;
    int prev2 = 1; // f(n-2)
    int prev1 = 2; // f(n-1)
    int curr;
    for (int i = 3; i <= n; i++) {
        curr = prev1 + prev2; // f(n) = f(n-1) + f(n-2)
        prev2 = prev1;
        prev1 = curr;
    }
    return prev1;
}

void inorder(struct TreeNode* root, int* tree, int* returnSize) {
    if(root == NULL) {
        return; // void 函数直接 return
    }
    inorder(root->left, tree, returnSize); // 左
    tree[*returnSize] = root->val; // 根
    (*returnSize)++; // 括号包裹，不加的话++的优先级高于*
    inorder(root->right, tree, returnSize); // 右
}

int* inorderTraversal(struct TreeNode* root, int* returnSize) {
    *returnSize = 0;
    int *tree = malloc(sizeof(int) * 300);
    inorder(root, tree, returnSize);
    return tree;
}

bool judge(struct TreeNode* left, struct TreeNode* right) {
    if(right==NULL && left==NULL){return true;}
    if(right==NULL || left==NULL){return false;}
    if(right->val != left->val){return false;}
    return judge(left->left,right->right) && judge(left->right,right->left);
}

bool isSymmetric(struct TreeNode* root) {
    if(root == NULL) {
        return true;
    }
    return judge(root,root);
}

int maxDepth(struct TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    int leftDepth = maxDepth(root->left);
    int rightDepth = maxDepth(root->right);
    return (leftDepth > rightDepth ? leftDepth : rightDepth) + 1;
}

int maxProfit(int* prices, int pricesSize) {
    int buy = prices[0];
    int money = 0;
    for(int i=0; i<pricesSize; i++) {
        if(prices[i]-buy>money){money=prices[i]-buy;}
        if(prices[i]<buy){buy=prices[i];}
    }
    return money;
}

int singleNumber(int* nums, int numsSize) {
    int result = 0;
    for(int i = 0; i < numsSize; i++) {
        result ^= nums[i]; // 成对的数会抵消，只剩单个的
    }
    return result;
}

bool hasCycle(struct ListNode *head) {
    struct ListNode *fast=head;
    struct ListNode *slow=head;
    while(fast!=NULL && fast->next!=NULL) {
        fast=fast->next->next;
        slow=slow->next;
        if(fast==slow) {
            return true;
        }
    }
    return false;
}

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    if (headA == NULL || headB == NULL) return NULL;
    struct ListNode *pA = headA, *pB = headB;
    while (pA != pB) {
        pA = (pA == NULL) ? headB : pA->next;
        pB = (pB == NULL) ? headA : pB->next;
    }
    return pA;
}

int majorityElement(int* nums, int numsSize) {
    int a=nums[0];
    int blood=1;
    for(int i=1;i<numsSize;i++) {
        int b=nums[i];
        if(a==b) {
            blood++;
        } else {
            blood--;
            if(blood<0) {
                a=nums[i];
                blood=0;
            }
        }
    }
    return a;
}

struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode *prev = NULL;
    struct ListNode *curr = head;
    struct ListNode *next = NULL;
    while (curr != NULL) {
        next = curr->next; // 保存下一个节点
        curr->next = prev; // 反转当前节点指向
        prev = curr; // prev 前移
        curr = next; // curr 前移
    }
    return prev; // 新头节点
}

struct TreeNode* invertTree(struct TreeNode* root) {
    // 1. 递归终止条件
    if (root == NULL) {
        return NULL;
    }
    // 2. 递归翻转左右子树
    struct TreeNode* left = invertTree(root->left);
    struct TreeNode* right = invertTree(root->right);
    // 3. 交换左右子树
    root->left = right;
    root->right = left;
    return root;
}

struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode *prev = NULL, *cur = head;
    while (cur) {
        struct ListNode* next = cur->next;
        cur->next = prev;
        prev = cur;
        cur = next;
    }
    return prev;
}

bool isPalindrome(struct ListNode* head) {
    if (head == NULL || head->next == NULL) return true;
    // 1. 快慢指针找中点
    struct ListNode *slow = head, *fast = head;
    while (fast->next && fast->next->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    // 2. 反转后半部分
    struct ListNode* secondHalfStart = reverseList(slow->next);
    // 3. 比较两部分
    struct ListNode *firstHalfStart = head;
    struct ListNode *secondHalfCopy = secondHalfStart;
    bool result = true;
    while (secondHalfStart) {
        if (firstHalfStart->val != secondHalfStart->val) {
            result = false;
            break;
        }
        firstHalfStart = firstHalfStart->next;
        secondHalfStart = secondHalfStart->next;
    }
    // 4. 恢复链表
    slow->next = reverseList(secondHalfCopy);
    return result;
}

bool isPalindrome(struct ListNode* head) {
    if (head == NULL || head->next == NULL) return true;
    int arr[100001];
    int n = 0;
    // 1. 链表转数组
    struct ListNode* cur = head;
    while (cur) {
        arr[n++] = cur->val;
        cur = cur->next;
    }
    // 2. 双指针判断回文
    int left = 0, right = n - 1;
    while (left < right) {
        if (arr[left] != arr[right]) return false;
        left++;
        right--;
    }
    return true;
}

void moveZeroes(int* nums, int numsSize) {
    int cnt=0;
    for(int i=0;i<numsSize;i++) {
        if(nums[i]==0) {
            cnt++;
        } else {
            int temp=nums[i-cnt];
            nums[i-cnt]=nums[i];
            nums[i]=temp;
        }
    }
}

int countOnes(int x) {
    int ones = 0;
    while (x > 0) {
        x &= (x - 1);
        ones++;
    }
    return ones;
}

int* countBits(int n, int* returnSize) {
    int*a=malloc(sizeof(int)*(n+1));
    *returnSize=n+1;
    for (int i = 0; i <= n; i++) {
        a[i] = countOnes(i);
    }
    return a;
}

int* findDisappearedNumbers(int* nums, int numsSize, int* returnSize) {
    for (int i = 0; i < numsSize; i++) {
        int index = abs(nums[i]) - 1;
        if (nums[index] > 0) {
            nums[index] = -nums[index]; // 标记为负
        }
    }
    int* result = malloc(sizeof(int) * numsSize);
    int count = 0;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > 0) { // 正数表示缺失
            result[count++] = i + 1;
        }
    }
    *returnSize = count;
    return result;
}

int hammingDistance(int x, int y) {
    unsigned int xor = x ^ y;
    int count = 0;
    while (xor) {
        xor &= xor - 1;
        count++;
    }
    return count;
}

int maxDepth(struct TreeNode* root, int* diameter) {
    if (root == NULL) return 0;
    int left = maxDepth(root->left, diameter);
    int right = maxDepth(root->right, diameter);
    // 更新全局最大直径（经过当前节点的路径）
    *diameter = (*diameter > left + right) ? *diameter : left + right;
    // 返回当前子树的深度（给父节点用）
    return (left > right ? left : right) + 1;
}

int diameterOfBinaryTree(struct TreeNode* root) {
    int diameter = 0;
    maxDepth(root, &diameter);
    return diameter;
}

struct TreeNode* mergeTrees(struct TreeNode* t1, struct TreeNode* t2) {
    if (t1 == NULL) {
        return t2;
    }
    if (t2 == NULL) {
        return t1;
    }
    struct TreeNode* merged = malloc(sizeof(struct TreeNode));
    merged->val = t1->val + t2->val;
    merged->left = mergeTrees(t1->left, t2->left);
    merged->right = mergeTrees(t1->right, t2->right);
    return merged;
}