力扣(LeetCode)刷题记录-1

1.两数之和

思路：暴力求解，题目给的好像是有序数组，可以用二分提高效率

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    int i,j;
    int* res = (int*)malloc(2 * sizeof(int));
    for(i = 0 ; i < numsSize ; i++)
        for(j = i + 1 ; j < numsSize ; j++)
            if((nums[i] + nums[j]) == target)
            {
                res[0] = i;
                res[1] = j;
                *returnSize = 2;
                return res;
            }
    return 0;
}

7.整数反转

思路，先存在数组里面，最后计算，返回时判断有没有溢出，给个long n = x是因为如果x = -2147483648的时候，n = -n会溢出

int reverse(int x){
    int flag = 1 , i = 0 , j;
    long res = 0 , n = x;
    int a[10];
    a[0] = 0;
    while(n)
    {
        if(n < 0)
        {
            n = -n;
            flag = 0;
        }
        a[i++] = n % 10;
        n = n/10;
    }
    if(a[0] != 0)
        res += (a[0] * pow(10,i-1));
    for(j = 1 ; j < i ; j++)
        res += (a[j] * pow(10,i-1-j));
    if(flag)
        return res > (pow(2,31) - 1)?0:res;
    else
        return -res < -pow(2,31)?0:-res;
}

9.回文数

思路：负数都不是，非负数的就转成字符串，反转判断

class Solution:
    def isPalindrome(self, x: int) -> bool:
        if(x < 0):
            return False
        else:
            return str(x) == str(x)[::-1]

思路：负数都不是，非负数存数组，前后对比，这里由于是数字的特点，也可以先把回文数计算出来，直接判断是否相等

bool isPalindrome(int x){
    int i = 0 , j = 0 , a[11];
    if(x < 0)
        return false;
    while(x > 0)
    {
        a[i++] = x % 10;
        x /= 10;
    }
    i--;
    while(i > j)
    {
        if(a[i--] != a[j++])
            return false;
    }
    return true;
}

13. 罗马数字转整数

思路：从前往后遍历

int romanToInt(char * s){
    int i = 0 , res = 0;
    while(s[i] != '\0')
    {
        switch(s[i])
        {
            case 'I':
                if(s[i+1] == 'V')   
                {
                    res += 4;
                    i += 2;
                    break;
                }
                else if(s[i+1] == 'X')
                {
                    res += 9;
                    i += 2;
                    break;
                }
                res += 1;
                i++;
                break;
            case 'V':
                res += 5;
                i++;
                break;
            case 'X':
                if(s[i+1] == 'L')
                {
                    res += 40;
                    i += 2;
                    break;
                }
                else if(s[i+1] == 'C')
                {
                    res += 90;
                    i += 2;
                    break;
                }
                res += 10;
                i++;
                break;
            case 'L':
                res += 50;
                i++;
                break;
            case 'C':
                if(s[i+1] == 'D')
                {
                    res += 400;
                    i += 2;
                    break;
                }
                else if(s[i+1] == 'M')
                {
                    res += 900;
                    i += 2;
                    break;
                }
                res += 100;
                i++;
                break;
            case 'D':
                res += 500;
                i++;
                break;
            case 'M':
                res += 1000;
                i++;
                break;
            default:
                break;
        }
    }
    return res;
}

14. 最长公共前缀

思路：把第一个串当作模式串，然后按照顺序对比每一行每一列的值

char * longestCommonPrefix(char ** strs, int strsSize){
    if(strsSize == 0)
        return "";
    int i,j;
    char* ress = (char*)malloc(sizeof(char));
    for(i = 0 ; i < strlen(strs[0]) ; i++)
    {
        ress = (char*)realloc(ress,(i + 1) * sizeof(char));
        for(j = 1 ; j < strsSize ; j++)
        {
            if(strs[0][i] != strs[j][i])
            {
                *(ress + i * sizeof(char)) = '\0';
                return ress;
            }
        }
        *(ress + i * sizeof(char)) = strs[0][i];
    }
    ress = (char*)realloc(ress,(i + 1) * sizeof(char));
    *(ress + i * sizeof(char)) = '\0';
    return ress;
}

20. 有效的括号

思路：简单的顺序栈

bool isValid(char * s){
    if(strlen(s) == 0)
        return true;
    char str[strlen(s)];
    int top = 0 , i = 0;
    while(s[i] != '\0')
    {
        switch(s[i])
        {
            case '(':
            case '[':
            case '{':
                str[top++] = s[i];
                break;
            case ')':
                if(top && str[top-1] == '(')
                {
                    top--;
                    break;
                }
                else
                    return false;
            case ']':
                if(top && str[top-1] == '[')
                {
                    top--;
                    break;
                }
                else
                    return false;
            case '}':
                if(top && str[top-1] == '{')
                {
                    top--;
                    break;
                }
                else
                    return false;
        }
        i++;
    }
    return top?false:true;
}

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

思路：快慢下标

int removeDuplicates(int* nums, int numsSize){
    int i = 0 , j = 1;
    while(j < numsSize && i < numsSize)
    {
        if(nums[j] == nums[i])
            j++;
        else
            nums[++i] = nums[j++];
    }
    return numsSize ? i + 1 : 0;
}

27. 移除元素

思路：遍历，不相等就插进去

int removeElement(int* nums, int numsSize, int val){
    int i , j = 0;
    for(i = 0 ; i < numsSize ; i++)
        if(nums[i] != val)
            nums[j++] = nums[i];
    return j;
}

实现 strStr()

思路：简单的字符串模式匹配算法

int strStr(char * haystack, char * needle){
    int i = 0 , j = 0;
    while(i < strlen(haystack) && j < strlen(needle))
    {
        if(haystack[i] == needle[j])
        {
            i++;
            j++;
        }
        else
        {
            i = i - j + 1;
            j = 0;
        }
    }
    return (j >= strlen(needle))?(i - strlen(needle)):-1;
}

35.搜索插入位置

思路：二分查找

int searchInsert(int* nums, int numsSize, int target){
    int low = 0 , high = numsSize - 1 , mid;
    while(low <= high)
    {
        mid = (low + high) / 2;
        if(nums[mid] == target)
            return mid;
        if(nums[mid] > target)
            high = mid - 1;
        else
            low = mid + 1;
    }
    return low;
}