Leetcode刷题---daily一练---编程基础从0到1题库

已于 2024-04-01 21:50:58 修改
阅读量126 收藏
点赞数 3
分类专栏： 自我管理 文章标签： 学习
于 2024-03-24 23:01:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_30782215/article/details/123451480
版权

T1768：. - 力扣（LeetCode）

刷题时间：20240324

方法一：双指针法：

C语言题解：

char * mergeAlternately(char * word1, char * word2)
{
    char* mChar = (char*) malloc(strlen(word1) + strlen(word2) + 1);
    int i = 0, j = 0, k =0;
    for(;i < strlen(word1) && j < strlen(word2);)
    {
        mChar[k++] = word1[i++];
        mChar[k++] = word2[j++];
    }
    if (strlen(word1) > strlen(word2))
    {
        for(;i < strlen(word1); i++)
        {
            mChar[k++] = word1[i];
        }
    }
    else if(strlen(word1) < strlen(word2))
    {
        for(;j < strlen(word2); j++)
        {
            mChar[k++] = word2[j];
        }
    }
    mChar[k] = '\0';
    return mChar;
}

C语言题解方法二：

char * mergeAlternately(char * word1, char * word2){
    char *ans = (char *)calloc(1, strlen(word1) + strlen(word2) + 1), *p = ans;
    while (*word1 && *word2)
    {
        *p ++ = *word1 ++;
        *p ++ = *word2 ++;
    }
    while (*word1) *p ++ = *word1 ++;
    while (*word2) *p ++ = *word2 ++;
    return ans;
}

C++题解：

class Solution {
public:
    string mergeAlternately(string word1, string word2) {
        string retString;
        retString.reserve(word1.length() + word2.size());
        int i = 0, j = 0;
        while(i < word1.length() || j < word2.size()) {
            if (i < word1.size()) {
                retString.push_back(word1[i++]);
            }
            if (j < word2.length()) {
                retString.push_back(word2[j++]);
            }
        }
        return retString;
    }
};

java题解：

class Solution {
    public String mergeAlternately(String word1, String word2) {
        int m = word1.length();
        int n = word2.length();

        int i = 0, j = 0;
        StringBuilder ans = new StringBuilder();
        while(i < m || j < n) {
            if (i < m) {
                ans.append(word1.charAt(i++));
            }
            if (j < n) {
                ans.append(word2.charAt(j++));
            }
        }
        return ans.toString();
    }
}

方法二：单指针法：

class Solution {
public:
    string mergeAlternately(string word1, string word2) {
        int n = word1.length();
        int m = word2.size();
        string retString;
        int i = 0;
        while(i < n || i < m) {
            if (i < n)
                retString += word1[i];

            if (i < m) {
                retString += word2[i];
            }
            i++;
        }
        return retString;
    }
};

T389 刷题时间：20240325

方法一：计算字符的个数

C语言题解

char findTheDifference(char* s, char* t) {
    int count_char[26] = {0};
    //memset(cnt, 0, sizeof(cnt));
    for(int i = 0; i < strlen(s); i++) {
        //这个数组元素的值表示字符i一共有多少个
        //减去字符‘a’的目的是为了确保下标在0到25之间，因为小写字母一共有26个
        count_char[s[i] - 'a']++; 
    }
    for( int j = 0; j < strlen(t); j++) {
        count_char[t[j] -'a']--;
        if(count_char[t[j] - 'a'] < 0) {
            return t[j];
        }
    }
    return '\0';
}

C++题解

class Solution {
public:
    char findTheDifference(string s, string t) {
        vector<int> countChar(26, 0); //注意是小括号
        for(char c: s) {
            countChar[c - 'a']++;
        }
        for(char c: t) {
            countChar[c - 'a']--;
            if (countChar[c -'a'] < 0)
                return c;
        }
        return ' ';
    }
};

方法二：求字符对应的asii码值和

C语言：

//这个思维真的很奇妙：明确字符可以自动转换成asii码值
char findTheDifference(char* s, char* t) {
    int as = 0, at = 0;
    for (int i = 0; i < strlen(s); i++) {
        as += s[i];
    }
    for (int i =0; i < strlen(t); i ++) {
        at += t[i];
    }
    return at - as;
}
上面的代码使用while简化
char findTheDifference(char* s, char* t) {
    int sSum = 0, tSum = 0;
    while(*s) {
        sSum += *s++;
    }
    while (*t) {
        tSum += *t++;
    }
    return tSum - sSum;
}

C++ 版本

class Solution {
public:
    char findTheDifference(string s, string t) {
        int sumS = 0, sumT = 0;
        for(char c: s) {
            sumS += c;
        }
        for(char c: t) {
            sumT += c;
        }
        return sumT - sumS;
    }
};

//采用while的写法
class Solution {
public:
    char findTheDifference(string s, string t) {
        int sumS = 0, sumT = 0, i = 0, j = 0;
        while(i < s.length()) {
            sumS += s[i++];
        }
        while (j < t.size()) {
            sumT += t[j++];
        }
        return sumT - sumS;
    }
};

java版本；；需要强制类型转换成char

class Solution {
    public char findTheDifference(String s, String t) {
        int sumS = 0, sumT = 0, i = 0;
        while(i < s.length()) {
            sumS += s.charAt(i++);
        }
        for (int j = 0; j < t.length(); j++) {
            sumT += t.charAt(j);
        }
        return (char)(sumT - sumS);
    }
}

//这个是先把t的字符都加起来，然后把s的字符一个个减去
class Solution {
    public char findTheDifference(String s, String t) {
        if (0 == s.length()) {
            return t.charAt(0);
        }
        int temp = 0;
        for(int i = 0; i < t.length(); i++) {
            temp += t.charAt(i);
        }
        int j = 0;
        while(j < s.length()) {
            temp -= s.charAt(j++);
        }
        return (char)temp;
    }
}

T28刷题日期：20240326

方法一：暴力解题：

c题解

int strStr(char* haystack, char* needle) {
    int m = strlen(haystack), n = strlen(needle);
    int ret = -1;
    //i + n 的目的是为了减少循环次数，因为m - i >= n才有可能匹配成功
    //注意是<=
    for (int i = 0; i + n <= m; i++) {
        for (int j = 0; j < n; j++) {
            ret = i; //假设相等，记录下第一个匹配下标
            //i + j是因为i在内嵌的for里没有+1，所以就借助了j++来+1
            if(haystack[i + j] != needle[j]) {
                printf("i = %d, j = %d \n", i, j);
                ret = -1;
                break; //第一个字符都不相等，就没有必要继续比较下去了。
            }
        }
        if (-1 != ret) { //内嵌的for没有走break，而是自己完美循环结束，说明匹配成功了
            return ret;
        }
    }
    return ret;
}

C++题解

class Solution {
public:
    int strStr(string haystack, string needle) {
        int m = haystack.length(), n = needle.size();
        int ret = -1;
        for(int i = 0; i + n <= m; i++) {
            ret = i;
            for (int j = 0; j < n; j++) {
                if(haystack[i +j] != needle[j]) {
                    ret = -1;
                    break;
                }
            }
            if (-1 != ret) return ret;
        }
        return ret;
    }
};

java题解

class Solution {
    public int strStr(String haystack, String needle) {
        int m = haystack.length(), n = needle.length();
        int ret = -1;
        for(int i = 0; i + n <= m; i++) {
            ret = i;
            for (int j = 0; j < n; j++) {
                if(haystack.charAt(i + j) != needle.charAt(j)) {
                    ret = -1;
                    break;
                }
            }
            if (-1 != ret) return ret;
        }
        return ret;
    }
}

T242刷题时间20240327

c语言题解

bool isAnagram(char* s, char* t) {
    if (strlen(s) != strlen(t)) return false;

    int count_s[26] = {0};
    int count_t[26] = {0};
    int max_index = 0;
    for (int i = 0; i < strlen(s); i++) {
        count_s[s[i] - 'a']++; 
        count_t[t[i] - 'a']++;
        max_index = max_index > s[i] -'a' ? max_index : s[i] -'a';
        max_index = max_index > t[i] -'a' ? max_index : t[i] -'a';
    }
    for (int j = 0; j < max_index; j++) { //这里循环次数可能远大于字符的长度，最大为26
         if (count_s[j] != count_t[j]) return false;
    }
    return true;  
}

//优化成用一个数组，可以减少循环次数为字符的长度n
bool isAnagram(char* s, char* t) {
    int len_s = strlen(s), len_t = strlen(t);
    if (len_s != len_t) {
        return false;
    }
    int table[26]; //共用了同一个table数组
    memset(table, 0, sizeof(table));
    for (int i = 0; i < len_s; ++i) {
        table[s[i] - 'a']++;
    }
    for (int i = 0; i < len_t; ++i) {
        table[t[i] - 'a']--;
        if (table[t[i] - 'a'] < 0) {
            return false;
        }
    }
    return true;
}

//另一种解法
bool isAnagram(char* s, char* t) {
    int len_s = strlen(s), len_t = strlen(t);
    if (len_s != len_t) {
        return false;
    }
    int table[26]; //共用了同一个table数组
    memset(table, 0, sizeof(table));
    for (int i = 0; i < len_s; ++i) {
        table[s[i] - 'a']++;
        table[t[i] - 'a']--;
    }
    for (int i = 0; i < 26; ++i) {
        if (0 > table[i]) return false;
    }
    return true;
}

C++题解

class Solution {
public:
    bool isAnagram(string s, string t) {
        int len_s = s.length(), len_t = t.size();
        if (len_s != len_t) {
            return false;
        }
        int table[26]; // 共用了同一个table数组
        memset(table, 0, sizeof(table));
        sort(s.begin(), s.end());
        sort(t.begin(), t.end());

        for (int i = 0; i < len_s; ++i) {
            table[s[i] - 'a']++;
            table[t[i] - 'a']--;
            if (table[s[i] - 'a'] > 0) //比较巧妙的是这里，但是需要先对字符排序
                return false;
        }
        return true;
    }
};

T283刷题时间：20240328

// 双指针法：
//  如果数组没有0，那么快慢指针始终指向同一个位置，不需要交换；
//  如果数组有0，快指针先走一步，此时慢指针对应的就是0，所以要交换
void swap(int* a, int* b) {
    int t = *a;
    *a = *b;
    *b = t;
}

void moveZeroes(int* nums, int numsSize) {
    int left = 0, right = 0;
    while (right < numsSize) {
        if (nums[right]) {
            if (left != right) { //要先判断，然后再left++
                swap(nums + left, nums + right);
            }
            left++;
        }
        right++;
    }
}

//解题思路：把非零的元素，按原有顺序陆续插入nums[0]开始的位置
//插入结束后，后面空余的补零。
void moveZeroes(int *nums, int numsSize) {
    int indexNoZeros = 0, index = 0;
    while (index < numsSize) {
        if (nums[index] != 0) {
            nums[indexNoZeros++] = nums[index];
        }
        index++;
    }
    for (int i = indexNoZeros; i < numsSize; i++) {
        nums[i] = 0;
    }
}

T1822刷题时间：20240329

C语言题解：

//方法一：每次遇到奇数就对符号标志取反
int arraySign(int* nums, int numsSize) {
  int sign = 1;
  for (int i = 0; i < numsSize; i++) {
    if (0 == nums[i]) return 0;
    if (nums[i] < 0) sign = -sign;
  }
  return sign;
}

//方法二：看负数的个数，奇数个负数的话，那乘积就是负数
int64_t arraySign(int* nums, int numsSize) {
    int64_t negativeN_count = 1;
    for(int i = 0; i <numsSize; i++) {
        if (0 == nums[i]) return 0;
        if (nums[i] < 0) negativeN_count++;
    }
    if (negativeN_count % 2) return 1;
    else return -1;
}

T1502 刷题时间：20240331

void swap(int * a, int *b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}
void sortArr(int *arr, int arrSize) {
    for (int i = 0; i < arrSize; i++) {
        for (int j = i + 1; j < arrSize; j++) {
            if (arr[i] > arr[j]) swap(&arr[i], &arr[j]);
        }
    }
}
bool canMakeArithmeticProgression(int* arr, int arrSize) {
    sortArr(arr, arrSize);
    int tmp = arr[1] - arr[0];
    for (int i = 1; i < arrSize; i++) {
        if (arr[i] - arr[i - 1] != tmp) return false;
    }
    return true;
}

T896 刷题时间20240401

//逆向思维：不是增，也不是减，那就不是单调数列了
bool isMonotonic(int* nums, int numsSize) {
    //假设是单调数列，单调增或减
    bool bigger_flag = true, smaller_flag = true;
    for (int i = 0; i < numsSize - 1; i++) {
        if (nums[i] > nums[i + 1]) {
            bigger_flag = false; //不是单调增
        }
        if (nums[i] < nums[i + 1]) {
            smaller_flag = false; //不是单调减
        }
    }
    return bigger_flag || smaller_flag; 
}

enjoife
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值