LeetCode编程笔记--C语言

已于 2022-12-09 16:53:59 修改
阅读量715 收藏
点赞数
文章标签： leetcode 算法 数据结构
于 2022-11-20 08:02:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60337039/article/details/127827996
版权

11月12日

  • 绝对值函数 abs -------------- #include<math.h>
  • 快排函数 qsort --------------- #include<stdlib.h>
 void qsort ( 
    void* base, 		//要排序的目标数组
    size_t num,     	//待排序的元素个数
    size_t width,       //一个元素的大小，单位是字节
    int(*cmp)(const void* e1, const void* e2) // e1 - e2 为升序，反之为降序
);

其中cmp是函数指针，cmp指向的是：排序时，用来比较两个元素的函数。需要自己编写。
参考链接：qsort排序

821.字符串中所有字符到某一个字符的最短距离

https://leetcode.cn/problems/shortest-distance-to-a-character/

  1. 找到单个字符到某一个字符的最短距离
  2. 遍历整个字符串

题解：

/**
 1. Note: The returned array must be malloced, assume caller calls free().
 */
int* shortestToChar(char * s, char c, int* returnSize){
    int size = strlen(s);
    *returnSize = size;
    int temp = 0;
    int *answer = (int*)malloc(sizeof(int) * size);

    for (int i = 0; i < size; i++) {
        answer[i] = 1000;
    }
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) { // 找出一个字符到某一个字符的最短距离
            if (s[j] == c) {
                int temp = abs(i - j);
                if (answer[i] > temp) {
                    answer[i] = temp;
                }
            }
        }
        printf("%d ", answer[i]);
    }

    return answer;
}

int* shortestToChar(char * s, char c, int* returnSize){
    int size = strlen(s);
    *returnSize = size;
    int temp = 0;
    int *answer = (int*)malloc(sizeof(int) * size);

    for (int i = 0; i < size; i++) {
        answer[i] = 1000;
    }
    int left = size;
    int right = size;
    for (int i = 0; i < size; i++) {
        for (int j = i; j >= 0; j--) { // 向左找最近的字符c
            if (s[j] == c) {
                left = abs(i - j);
                break;
            }
        }
        for (int j = i; j < size; j++) { // 向右找最近的字符c
            if (s[j] == c) { 
                right = abs(i - j);
                break;
            }
        }

        answer[i] = left > right ? right : left;
        left = size;
        right = size;
        printf("%d ", answer[i]);
    }

    return answer;
}

217.存在重复元素

https://leetcode.cn/problems/contains-duplicate/

  1. 排序
  2. 遍历并判断相邻的两个元素是否相等

题解：

#include <stdlib.h>

int myCmp(const void * a, const void* b) {
    return (*(int*)a - *(int*)b);
}

bool containsDuplicate(int* nums, int numsSize){
    qsort(nums, numsSize, sizeof(nums[0]), myCmp);

    for (int i = 0; i < numsSize - 1; i++) {
        if (nums[i] == nums[i+1]) {
            return true;
        }
    }
    return false;
}

11月13日

  • sprintf 、itoa----- 可以将整数转换成字符串，
  • atoi -------- 可以将字符串转换成整数（0-10），数字字符串转换成整形数字

atoi函数参考链接：https://cloud.tencent.com/developer/article/2153891?from=15425

1281. 整数的各位积和之差

https://leetcode.cn/problems/subtract-the-product-and-sum-of-digits-of-an-integer/

  1. 将整数转换字符串
  2. 求和、求积 作差返回
int subtractProductAndSum(int n){
    char buf[10000];
    sprintf(buf, "%d", n);
    printf("%s\n", buf);
    int sum = 0;
    int b = 1;
    for (int i = 0; i < strlen(buf); i++) {
        sum += buf[i] - '0';
        b *= buf[i] - '0';
    }

    return b - sum;
}

面试题 01.06. 字符串压缩

https://leetcode.cn/problems/compress-string-lcci/description/

53. 最大子数组和

https://leetcode.cn/problems/maximum-subarray/?envType=study-plan&id=shu-ju-jie-gou-ru-men&plan=data-structures&plan_progress=197r58g

  1. 找到包含自己的最大子数组和
  2. 遍历所有数数组
int maxSubArray(int* nums, int numsSize){
    // maxNums[0] = nums[0]
    // maxNums[i] = max(nums[i] + maxNUmx[i-1], num[i])
    // max = max(max, maxNums[i]);

    int* maxSum = (int*)malloc(sizeof(int) * numsSize);
    maxSum[0] = nums[0];
    int max = maxSum[0];

    for (int i = 1; i < numsSize; i++) {
        maxSum[i] = fmax(nums[i] + maxSum[i - 1], nums[i]);
        if (maxSum[i] > max) {
            max = maxSum[i];
        }
    }

    return max;
}

11月14日

202. 快乐数

https://leetcode.cn/problems/happy-number/description/
使用快慢指针来求解,fast 走两次，low走一次。快慢指针是处理有环退出问题的必杀技。


int myFuction(int n)
{   
    int ret = 0;
    while (n != 0) {
        int temp = n % 10;
        ret += temp * temp;
        n /= 10;
    }
    return ret;
}


bool isHappy(int n){
    int fast = n;
    int low = n;

    do {
        low = myFuction(low);
        fast = myFuction(fast);
        fast = myFuction(fast);
    } while (fast != low);

    if (fast == 1) {
        return true;
    }
    return false;
}

643. 大小为k的最大子数组和

https://leetcode.cn/problems/maximum-average-subarray-i/description/

  • 使用滑动窗口保存k个数的和
double findMaxAverage(int* nums, int numsSize, int k){
    int sum = 0;
    for (int i = 0; i < k; i++) { // 前k个数之和
        sum += nums[i];
    }

    int left = 0;
    int right = k;
    int temp = sum;
    
    while (right < numsSize) {
        temp += nums[right++] - nums[left++]; // 保存滑动窗口的和
        if (temp > sum) {   // 保存最大值到sum
            sum = temp;
        }
    }

    return sum / (double)k;
}

11月16日

349. 两个数组的交集

https://leetcode.cn/problems/intersection-of-two-arrays/description/
1、两个数组排序
2、双指针移动
3、相等时并判断此值与将要插入的值的前一个比较（相等不插入）。
4、那个小（升序就小，降序就大）就向下移动

int cmp(const void *a, const void *b)
{
    return *(int *)a - *(int *)b;
}

int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){
    qsort(nums1, nums1Size, sizeof(nums1[0]), cmp);
    qsort(nums2, nums2Size, sizeof(nums2[0]), cmp);

    int *ret = (int *)malloc(sizeof(int) * 1000);
    (*returnSize) = 0; // 返回数组的大小可以用做index
    int index1 = 0;
    int index2 = 0;

    while (index1 < nums1Size && index2 < nums2Size) {
        if (nums1[index1] == nums2[index2]) {
            // 保证ret的唯一性，将相同的值与将前一个ret中的值比较区重复
            if ((*returnSize == 0) || nums1[index1] != ret[*returnSize - 1]) {
                ret[(*returnSize)++] = nums1[index1];
            }
            index1++;
            index2++;
        } else if (nums1[index1] > nums2[index2]) {
            index2++;
        } else {
            index1++;
        }
        
    }
    
    return ret;
}

哈希数组映射解法
https://leetcode.cn/problems/intersection-of-two-arrays/solutions/1947189/349-liang-ge-shu-zu-de-jiao-ji-ha-xi-bia-w8hl/

350. 两个数组的交集 II

https://leetcode.cn/problems/intersection-of-two-arrays-ii/
使用哈希数组映射解法 — 针对有限的个数
1、初始化哈希数组
2、初始化哈希数组，value为key的个数
3、查找匹配，匹配到一个，value–

int* intersect(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){

    int min = (nums1Size > nums2Size)? nums2Size : nums1Size;
    int hash[1001] = {0};
    int *ret = (int*)malloc(sizeof(int) * min);
    int index = 0;

    for (int i = 0; i < nums1Size; i++) {
        hash[nums1[i]]++;
    }

    for (int i = 0; i < nums2Size; i++) {
        if (hash[nums2[i]] > 0) {
            ret[index++] = nums2[i];
            hash[nums2[i]]--;
        } 
    }

    (*returnSize) = index;
    return ret;
}

11月17日

1002. 查找共用字符

使用二维的哈希数组映射解法 — 针对有限的个数
https://leetcode.cn/problems/find-common-characters/description/

  1. 使用一个二维数组哈希表保存words中字符出现的次数
  2. 获取每一列的最小值 最小值为几就输出当前字符多少次

在这里插入图片描述

char ** commonChars(char ** words, int wordsSize, int* returnSize){
    
    char hash[101][26] = {0};
    int j = 0;
    int row = 0;
    // 使用一个二维数组哈希表保存words中字符出现的次数
    for (int i = 0; i < wordsSize; i++) {
        j = 0;
        while (words[i][j] != '\0') {
            hash[row][words[i][j] - 'a']++;
            j++;
        }
        row++;
    }
    // 二维数组的开辟 == 开辟一个指针数组
    char **ret = (char**)malloc(sizeof(char*) * 101);
    int ret_row = 0;
    for (int i = 0; i < 101; i++) {
        ret[i] = (char*)malloc(sizeof(char)*2);
        memset(ret[i], 0, 2);
    }
    // 获取每一列的最小值 最小值为几就输出当前字符多少次
    for (int i = 0; i < 26; i++) {
        for (int k = 1; k < wordsSize; k++) {
            if (hash[0][i] > hash[k][i]) { // 把每一列的最小值放到第一行
                hash[0][i] = hash[k][i];
            }
        }
        for (int index = 0; index < hash[0][i]; index++) { // 输出到ret中
            ret[ret_row++][0] = i + 'a';
        }
    }
    *returnSize = ret_row;
    return ret;
}

更多hash类型的题目请参考
https://leetcode.cn/problems/find-common-characters/solutions/445914/1002-cha-zhao-chang-yong-zi-fu-ha-xi-fa-jing-dian-/

代码随想录编程

https://leetcode.cn/problems/remove-duplicates-from-sorted-array/

11月20日

26. 删除有序数组中的重复项

https://leetcode.cn/problems/remove-duplicates-from-sorted-array-ii/description/

  • 将要插入的元素 不等于新数组的最后一个元素时。直接插入
int removeDuplicates(int* nums, int numsSize){
    int slow = 0;
    int fast = 0;
    nums[slow] = nums[fast];
    for (fast = 1; fast < numsSize; fast++) {
        if (nums[slow] != nums[fast]) {
            nums[++slow] = nums[fast];
        }
    }
    return ++slow;
}

80. 删除有序数组中的重复项 II

https://leetcode.cn/problems/remove-duplicates-from-sorted-array-ii/submissions/383397313/

  • 将要插入的元素 不等于新数组的最后一个元素时。直接插入并标记为count = 1;
  • 将要插入的元素 等于新数组的最后一个元素时，判断是否count == 1 ；则添加进去，并将cont =1;
int removeDuplicates(int* nums, int numsSize){
    int count = 0;
    int slow = 0;
    int fast = 0;
    count = 1;
    for (fast = 1; fast < numsSize; fast++) {
        if (nums[slow] != nums[fast]) {
            nums[++slow] = nums[fast];
            count = 1;
        } else if (nums[slow] == nums[fast] && count == 1) {
            nums[++slow] = nums[fast];
            count = 0;
        }
    }

    return slow + 1;
}

12月06

203. 移除链表元素

https://leetcode.cn/problems/remove-linked-list-elements/description/

struct ListNode* removeElements(struct ListNode* head, int val){
    if (head == NULL) {
        return head;
    }
    struct ListNode *myHead = (struct ListNode*)malloc(sizeof(struct ListNode));
    myHead->next = head;
    struct ListNode *p = myHead;

    while (p->next != NULL) {
        // printf("%d \n", p->next->val);
        struct ListNode *temp = p->next;
        if (temp->val == val) {
            p->next = p->next->next;
            free(temp);
        } else {
            p = p->next;
        } 
    }

    return myHead->next;
}

206. 反转链表

https://leetcode.cn/problems/reverse-linked-list/description/

  • 转换为遍历链表将节点插入新的链表中
struct ListNode* reverseList(struct ListNode* head){
    struct ListNode *myHead = (struct ListNode *)malloc(sizeof(struct ListNode)); // 新链表的空头节点
    myHead->next = NULL;
    struct ListNode *tempHead = myHead;
    
    struct ListNode *temp;
    struct ListNode *p = head;
    while (p != NULL) { // 遍历链表
        temp = p;
        p = p->next;

        temp->next = tempHead->next; // 将原来链表中的节点插入新的链表中
        tempHead->next = temp;
    }

    return tempHead->next;
}

24. 两两交换链表中的节点

https://leetcode.cn/problems/swap-nodes-in-pairs/description/

struct ListNode* swapPairs(struct ListNode* head){
    struct ListNode* myHead = (struct ListNode*)malloc(sizeof(struct ListNode));
    myHead->next = head;

    struct ListNode* temp = myHead;
    while (temp->next != NULL && temp->next->next != NULL) {
        struct ListNode* node_1 = temp->next;
        struct ListNode* node_2 = temp->next->next;

        temp->next = node_2; // 表示第0个节点的next指向第2个节点，
        node_1->next = node_2->next;// 表示将第一个节点的next指向第4个节点，
        node_2->next = node_1; // 表示将第二个节点的next 指向第1个节点
        temp = node_1;
    }

    return myHead->next;
}

siu

19. 删除链表的倒数第 N 个结点

https://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/

struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
    struct ListNode* myHead = (struct ListNode *)malloc(sizeof(struct ListNode));
    myHead->next = head;

    struct ListNode* p = myHead;
    int count = 0;

    while (p->next != NULL) {
        count++;
        p = p->next;
    }
    printf("%d\n", count);
    p = myHead;
    int num = count - n;
    while (num--) {
        p = p->next;
    }
    struct ListNode* temp = p->next;
    p->next = p->next->next;
    free(temp);

    return myHead->next;
}

面试题 02.07. 链表相交

https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/description/

 struct ListNode *Fuction(struct ListNode *headA, struct ListNode *headB)
 {
    while(headA->next != headB->next) {
        headA = headA->next;
        headB = headB->next;
    }
    if (headA->next == NULL) {
        return NULL;
    }
    return headA->next;
 }

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    if (headA == NULL || headB == NULL) {
        return NULL;
    }
    struct ListNode *pAHead = (struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode *pBHead = (struct ListNode*)malloc(sizeof(struct ListNode));
    pAHead->next = headA;
    pBHead->next = headB;

    struct ListNode *pA = pAHead;
    struct ListNode *pB = pBHead;
    int size_a = 0;
    int size_b = 0;
    while (pA->next != NULL) {
        size_a++;
        pA = pA->next;
    }
    // printf("%d\n", size_a);
    while (pB->next != NULL) {
        size_b++;
        pB = pB->next;
    }
    // printf("%d\n", size_b);
    if (size_a > size_b) {
        for (int i = 0; i < size_a - size_b; i++) {
            pAHead = pAHead->next;
        }
    } else if (size_a < size_b) {
        for (int i = 0; i < size_b - size_a; i++) {
            pBHead = pBHead->next;
        }
    }

    return Fuction(pAHead, pBHead);
}

12月07日

142. 环形链表 II

https://leetcode.cn/problems/linked-list-cycle-ii/description/

struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode* myHead = (struct ListNode*)malloc(sizeof(struct ListNode));
    myHead->next = head;

    struct ListNode *p = myHead;
    while (p->next != NULL) {
        struct ListNode* temp = myHead;
        while(temp->next != p->next) { // 循环判断p->next->next 是否指向前面的节点
            if (temp->next == p->next->next) {
                return p->next->next;
            }
            temp = temp->next;
        }

        if (p->next == p->next->next) { // 判断自己指向自己的情况
            return p->next->next;
        }
        p = p->next;
    }

    return NULL;
}

59. 螺旋矩阵 II

https://leetcode.cn/problems/spiral-matrix-ii/description/

int** generateMatrix(int n, int* returnSize, int** returnColumnSizes){
    *returnSize = n;
    *returnColumnSizes = (int*)malloc(sizeof(int)*n);
    int** ret = (int**)malloc(sizeof(int*) * (*returnSize));
    for (int i = 0; i < n; i++) {
        ret[i] = (int*)malloc(sizeof(int) * n);
        memset(ret[i], 0, sizeof(int) * n);
        (*returnColumnSizes)[i] = n;
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            //printf("%d ", ret[i][i]);
        }
        //printf("\n");
    }
    int left = 0;
    int right = n - 1;
    int up = 0;
    int down = n -1;
    int index = 1;

    while (index <= n*n) {
        for(int i = left; i <= right; i++){
            ret[up][i] = index++;
            printf("%d ", ret[up][i]);
        }
        printf("\n");
        up++;
        for (int i = up; i <= down; i++) {
            ret[i][right] = index++;
            printf("%d ", ret[i][right]);
        }
        printf("\n");
        right--;
        for (int i = right; i >= left; i--) {
            ret[down][i] = index++;
            printf("%d ", ret[down][i]);
        }
        printf("\n");
        down--;
        for (int i = down; i >= up; i--) {
            ret[i][left] = index++;
            printf("%d ", ret[i][left]);
        }
        printf("\n");
        left++;
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", ret[i][j]);
        }
        printf("\n");
    }
    return ret;
}
天上掉下个猪八戒~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【C语言刷LeetCode】索引篇
kinbo88的专栏
02-11 2395
今天开始记录下自己用C语言刷的LeetCode吧，曾经以为选择做嵌入式就不用太理会算法，C语言不可能刷LeetCode，但最后居然不搞嵌入式了，C语言也必须要刷题，终究逃不了。 1.两数之和（E） ...
LeetCode C语言实现
qq_38816217的博客
08-23 1313
1 两数之和 C实现 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] 来源：力扣（LeetCode） nums为给定数组，numsSize为数组成员数，target为求和目标值，retur
【C语言刷题——Leetcode12道题】带你起飞，飞进垃圾堆
热门推荐
weixin_60478154的博客
06-24 1万+
刷题之——Leetcode12道简单题，通过这12道简单题，让你对Leetcode有所新的理解，增强自己的做题能力。下面，直接进入我们的题目。👇这道题Leetcode难度归类为中等，但是我感觉我们撑一撑应该还是能做得出来的（bushi）：这里的变量为了方便说明就使用我做题过程中命名的名字了🌹解题思路：首先，我们定义一个变量（eor）初始化为0去遍历按位异或数组中的所有元素，此时得到的是只出现一次的两个元素的二进制异或结果。然后去对二进制的结果进行处理：对于两个不同的数字，异或出来的二进制结果中为1的话说..
（C语言版）力扣（LeetCode）栈和队列面试题
立志做一个高产且细节博主
05-13 1305
20. 有效的括号 解法一：建立栈解决 解法二：数组模拟栈解决 225. 用队列实现栈 解法：两个队列实现栈 232. 用栈实现队列 解法：两个栈实现队列 622. 设计循环队列
Leetcode学习（Python语言）
最新发布
wqufhu的博客
05-28 198
【代码】Leetcode学习（C语言）
用 C 语言来刷 LeetCode，网友直呼：那是真的牛批...
GitHubDaily
12-28 8894
公众号关注“GitHubDaily”设为 “星标”，每天带你逛 GitHub！大家好，我是小 G。如果你是计算机科班出身，那么 C 语言，估计是你在初入编程时，最早接触的编程语言之一。作...
一、C语言编程LeetCode数据结构题
qq_43751506的博客
06-27 469
使用C语言编程数据结构题目
LeetCode 求众数 C语言
qq_43874157的博客
07-22 464
思路 方法一：先排序，再取中间的数，则一定是众数 方法二：LeetCode官方题解中的投票算法，感觉思路真的很棒，首先假设第一个数为众数记为suf，遍历数组，若与suf相等的数则count+1，若不相等则-1，当count==0时，将suf改为此时的元素值，这样去掉了相等数量的两个元素后，当最后剩下的元素中众数一定还是多于其他元素，一直会保持count>0，suf还为众数 //方法一 i...
leetcode中文版-programming-notes:编程笔记
06-29
的编程笔记 指尖之间，我接触编程已经五年多了。 从第一次接触C语言到现在的计算机编程知识，一波三折来之不易。 这个在线笔记记录了我在学习计算机编程过程中的一点。 一点点地。 关于 - 关于本文档 本笔记的原始...
谷歌师兄的leetcode刷题笔记-avr-lvds-lcd:从8位AVR微控制器驱动旧笔记本电脑显示器
06-30
这部分涵盖了AVR微控制器的C语言编程，包括初始化、中断处理、定时器配置等。编程的重点是生成正确的LVDS信号序列，以驱动LCD显示图像。这通常涉及到精心设计的帧缓冲区管理，以及如何高效地将缓冲区内容转换为LVDS...
vs没报错leetcode报错-data-structure-and-algorithm:《数据结构与算法分析》笔记+代码
06-30
学习知识点：在《算法：C语言实现》，《数据结构与算法分析C语言描述》看知识点 2. 跟老师学解题：在吴师兄找练习题， 3. 练习解题：在LeetCode练习3道题，剑指Offset练习 每道题给自己20~30分钟的思考时间, 想不...
cpp-算法学习笔记
08-16
C++是C语言的扩展，它引入了面向对象编程的概念，如类、对象、封装、继承和多态性。由于C++对底层硬件的控制程度高，因此它是实现算法的理想选择，特别是在性能敏感的应用中。 在算法学习笔记中，你可以期待涵盖...
leetcode答案-notes:写LeetCode的解题记录、算法、技术分享等
06-30
C语言则是经典且基础的编程语言，对内存管理有直接控制，常用于系统级编程和嵌入式开发。选择不同的语言可以锻炼不同的编程思维和技巧，同时也能对比不同语言在解决问题时的效率和便捷性。 “答案有可能不是最优解...
Leetcode 常用函数总结（C语言版本）
peterandersen888的博客
05-23 1662
leetcode考试
leetcode刷题笔记（c语言）
q13099138865的博客
10-10 142
4.函数要返回一个线性表作为结果，在函数中要用malloc申请这个线性表内存，不能直接申请数组，因为函数结束这个数组会被销毁。2.接上一条，如果不在输出数组末尾写上'\0'，则会报地址错误，可以用msmset，或者结束了加'\0'1.力扣如果要返回数组指针，该数组首元素不能是空，否则系统认为数组内全是空。10.malloc申请的内存就算不返回用也要在末尾加'\0'，不然报错。6.int型变量如果使用负值，就报错，类似地址溢出的错误。11.a[10]是定义了有十个元素的数组，元素为从0~9。
LeetCode c语言解题思路+答案代码+多种解法+关键注释 GitHub持续更新
weixin_43512663的博客
12-17 9429
LeetCode c语言解题思路+答案代码+多种解法+关键注释 GitHub持续更新将在GitHub上记录LeetCode刷题过程代码地址使用vs2013编写调试.cpp文件中函数的结构 将在GitHub上记录LeetCode刷题过程 最近开始刷LeetCode，过程大概就是先自己思路做一遍，然后剖析学习大佬们提交的最高效的思路。 代码地址 https://github.com/zqxl/leet...
LeetCode 刷题笔记(C语言版 10月)
一条菜鸟鱼的博客
11-30 4761
LeetCode 刷题笔记 纯C语言实现
LeetCode刷题总结（C语言版）
凡物加倍磨治，皆能变化气质
01-02 5529
编程总结 每每刷完一道题后，其思想和精妙之处没有地方记录，本篇博客用以记录刷题过程中的遇到的算法和技巧 001）两数之和 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的两个整数。 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] ...
leetcode刷题总结--C语言
Mmyine的博客
02-25 1197
1、memset(目标，初始值，长度)； 长度一般用sizeof等表示，一般不用具体的数字，只适用于一维数组和指针，二维不适合 2、case 后面必须是一个整数，或者是结果为整数的表达式，但不能包含任何变量。 case 10: printf("..."); break; //正确 case 8+9: printf("..."); break; //正确 case 'A': printf("..."); break; //正确，字符和整数可以相互转换 case 'A'+19: printf("...")
AcWing_Tree题解1
08-04
"AcWing夏季LeetCode刷题活动介绍及树相关题目...AcWing的这个活动提供了一个系统学习和提升算法技能的机会，特别是对于树相关的数据结构和算法，参与者将通过实战练习和互动学习，提高自己的编程能力和问题解决能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值