leetcode-字符串-简单-C-第一部分

最新推荐文章于 2022-11-04 16:04:42 发布

Novelin

最新推荐文章于 2022-11-04 16:04:42 发布

阅读量617

点赞数 1

文章标签： c语言

本文链接：https://blog.csdn.net/qq_40860934/article/details/104866016

版权

文章目录

序号13
序号14
序号20
序号38
序号58
序号67
序号125
序号344
序号345
序号383
序号387
序号392
序号415
序号434
序号443
序号520
序号521
序号541
序号551
序号557

序号13

解析：由后一个字母和前一个字母大小比较，决定前一个字母的正负

模拟
存储字母对应值，可以用数组保存，也可以函数 switch 返回

int romanToInt(char * s){
    int value[150] = { 0 };
    value['I'] = 1; value['V'] = 5; value['X'] = 10;
    value['L'] = 50; value['C'] = 100; value['D'] = 500;
    value['M'] = 1000;
    int sum = 0;
    int preNum = value[s[0]];
    int num;

    for (int i = 1; s[i] != '\0'; i++)
    {
        num = value[s[i]];
        if (preNum < num)
            sum -= preNum;
        else
            sum += preNum;
        preNum = num;
    }
    sum += preNum;  //最后一个字母直接加
    return sum;
}

序号14

题目：编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。

解析：

模拟
逐个比较所有字符串的前缀

int isSame(char** strs, int strsSize, int pos)
{
    for (int i = 0; i < strsSize - 1; i++)
    {
        if (strs[i][pos] != strs[i+1][pos])
            return 0;
    }
    return 1;
}

char * longestCommonPrefix(char ** strs, int strsSize){
    if (strsSize == 0)
        return "";
    
    int len = strlen(strs[0]);
    char* ans = (char*)malloc(sizeof(char) * (len+1));  //还有一个\0
    strcpy(ans, strs[0]);  //最长前缀肯定在其中
    int cnt = 0;
    
    for (int i = 0; i < len; i++)
    {
        if (isSame(strs, strsSize, i))
            cnt++;
        else 
            break;    
    }
    ans[cnt] = '\0';  //截取字符串
    return ans;
}

序号20

题目：给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。

解析：

栈
现在的字符与栈顶的字符比较，匹配则出栈，否则入栈当前的字符
最后判断栈是否为空

bool isValid(char * s){
    if (s[0] == '\0')
        return true;

    char stack[100000];  //测试点没这么多... 也可以用链栈
    stack[0] = s[0];
    int top = 0;
    char ch;

    for (int i = 1; s[i] != '\0'; i++)
    {
        if (top == -1)
            stack[++top] = s[i];
        else
        {
            ch = stack[top];
            if ((ch == '(' && s[i] == ')') || (ch == '[' && s[i] == ']')
                || (ch == '{' && s[i] == '}'))
                top--;
            else
                stack[++top] = s[i];
        } 
    }
    if (top == -1)
        return true;
    else
        return false;
}

序号38

题目：
解析：

打表法
最后的答案过于长，可以直接打表，最后判断输出
模拟
按照要去生成数组

char* countAndSay(int n) {
    if (n == 1)
        return "1";

    char str[5000];
    strcpy(str, countAndSay(n - 1));
    int len = strlen(str);
    char cnt[50];
    static char ans[5000];
    strcpy(ans, "");
    for (int i = 0; i < len;)
    {
        int j = i + 1;
        while (j < len && str[j] == str[i])
            j++;
        sprintf(cnt, "%d", j - i);
        strcat(ans, cnt);
        char ch[2] = { str[i], '\0' };
        strcat(ans, ch);
        i = j;
    }
    return ans;
}

序号58

题目：给定一个仅包含大小写字母和空格 ’ ’ 的字符串 s，返回其最后一个单词的长度。如果字符串从左向右滚动显示，那么最后一个单词就是最后出现的单词。
如果不存在最后一个单词，请返回 0 。
说明：一个单词是指仅由字母组成、不包含任何空格字符的最大子字符串。

解析：

模拟
倒着遍历字符串，找单词

int lengthOfLastWord(char* s) {
	int len = strlen(s);
	int cnt = 0;
	for (int i = len - 1; i >= 0; --i)
	{
		while (i >= 0 && s[i] != ' ')
		{
			--i;
			++cnt;
		}
		if (cnt != 0)
			return cnt;
	}
	return 0;
}

序号67

题目：给定两个二进制字符串，返回他们的和（用二进制表示）。
输入为非空字符串且只包含数字 1 和 0。

解析：

模拟加法

char* addBinary(char* a, char* b) {
	int lenA = strlen(a);
	int lenB = strlen(b);
	int longLen, shortLen;
	char one[1000], two[1000];
	if (lenA > lenB)
	{
		strcpy(one, a);
		strcpy(two, b);
		longLen = lenA;
		shortLen = lenB;
	}
	else
	{
		strcpy(one, b);
		strcpy(two, a);
		longLen = lenB;
		shortLen = lenA;
	}
	int carry = 0;
	int temp, j;
	for (int i = shortLen - 1; i >= 0; --i)
	{
		j = longLen - (shortLen - i);
		temp = carry + two[i] - '0' + one[j] - '0';
        carry = temp / 2;
        one[j] = temp % 2 + '0';
	}
    for (j = j - 1; carry == 1 && j >= 0; --j)
    {
        temp = 1 + one[j] - '0';
        carry = temp / 2;
        one[j] = temp % 2 + '0';
    }
	char* ans = (char*)malloc(sizeof(char) * (longLen + 2));
	if (carry == 1)
	{
		strcpy(ans, "1");
		strcat(ans, one);
	}
    else
        strcpy(ans, one);
	return ans;
}

序号125

题目：给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
说明：本题中，我们将空字符串定义为有效的回文串。

解析：

模拟
先转换为只有字母和数字字符的字符串，并且都转为小写字母。再判断回文

bool isPalindrome(char* s) {
	static char dest[1000000];
	int len = 0;
	for (int i = 0; s[i] != '\0'; ++i)
	{
		if (isdigit(s[i]))
			dest[len++] = s[i];
		else if (isalpha(s[i]))
			dest[len++] = tolower(s[i]);
	}
	for (int i = 0; i < len/2; ++i)
	{
		if (dest[i] != dest[len - 1 - i])
			return false;
	}
	return true;
}

注：开很大的数组，用 static

序号344

题目：编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

解析：

模拟
交换头尾字符即可

void reverseString(char* s, int sSize) {
	char ch;
	for (int i = 0; i < sSize / 2; ++i)
	{
		ch = s[i];
		s[i] = s[sSize - 1 - i];
		s[sSize - 1 - i] = ch;
	}
}

序号345

题目：编写一个函数，以字符串作为输入，反转该字符串中的元音字母。

解析：

双指针
针对元音字母反转，需要双指针进行判断再反转

bool isYuan(char c)
{
	switch (c)
	{
	case 'a':
	case 'A':
	case 'e':
	case 'E':
	case 'i':
	case 'I':
	case 'o':
	case 'O':
	case 'u':
	case 'U':
		return true;
	}
	return false;
}

char* reverseVowels(char* s) {
	int len = strlen(s);
	int i = 0;
	int j = len - 1;
	char ch;
	while (i < j)
	{
		if (isYuan(s[i]) && isYuan(s[j]))
		{
			ch = s[i];
			s[i] = s[j];
			s[j] = ch;
			++i;
			--j;
		}
		else if (!isYuan(s[i]))
			++i;
		else
			--j;
	}
	return s;
}

序号383

题目：给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串ransom能不能由第二个字符串magazines里面的字符构成。如果可以构成，返回 true ；否则返回 false。
(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。)

解析：

散列记录
在第二个字符串中找到所需字母及其数量即可，不需要顺序

bool canConstruct(char* ransomNote, char* magazine) {
	int hash[128] = { 0 };
	for (int i = 0; ransomNote[i] != '\0'; ++i)
		hash[ransomNote[i]]++;
	for (int i = 0; magazine[i] != '\0'; ++i)
	{
		if (hash[magazine[i]] != 0)
			hash[magazine[i]]--;
	}
	for (int i = 0; i < 128; ++i)
	{
		if (hash[i] != 0)
			return false;
	}
	return true;
}

序号387

题目：给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。

解析：

散列记录
记录每个字母出现的次数，找到次数为 1 的，直接返回

int firstUniqChar(char* s) {
	int hash[128] = { 0 };
	for (int i = 0; s[i] != '\0'; ++i)
		hash[s[i]]++;
	for (int i = 0; s[i] != '\0'; ++i)
	{
		if (hash[s[i]] == 1)
			return i;
	}
	return -1;
}

序号392

题目：给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
你可以认为 s 和 t 中仅包含英文小写字母。字符串 t 可能会很长（长度 ~= 500,000），而 s 是个短字符串（长度 <=100）。
字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

解析：

模拟
只要按顺序找到所有字符就可以

bool isSubsequence(char * s, char * t){
    int len1 = strlen(s);
    int len2 = strlen(t);
    int i = 0;
    int j = 0;

    while (i < len1 && j < len2)
    {
        if (s[i] == t[j])
            i++;
        j++;
    }
    if (i == len1)
        return true;
    else 
        return false;
}

序号415

题目：给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。
注意：
num1 和num2 的长度都小于 5100.
num1 和num2 都只包含数字 0-9.
num1 和num2 都不包含任何前导零。
你不能使用任何內建 BigInteger 库，也不能直接将输入的字符串转换为整数形式。

解析：

模拟
注意字符串的赋值即可

char* addStrings(char* num1, char* num2) {
	char one[5102], two[5102];
	int oneLen, twoLen;
	if (strlen(num1) > strlen(num2))
	{
		strcpy(one, num1);
		strcpy(two, num2);
		oneLen = strlen(num1);
		twoLen = strlen(num2);
	}
	else
	{
		strcpy(one, num2);
		strcpy(two, num1);
		oneLen = strlen(num2);
		twoLen = strlen(num1);
	}
	int carry = 0;
	int i = twoLen - 1;
	int j = oneLen - 1;
	int temp;
	for (; i >= 0; --i,--j)
	{
		temp = one[j] - '0' + two[i] - '0' + carry;
		carry = temp / 10;
		one[j] = temp % 10 + '0';
	}
	for (; carry == 1 && j >= 0; --j)
	{
		temp = one[j] - '0' + 1;
		carry = temp / 10;
		one[j] = temp % 10 + '0';
	}
    char* ans = (char*)malloc(sizeof(char) * (oneLen + 2));
	if (carry == 1)
	{
		strcpy(ans, "1");
		strcat(ans, one);
		return ans;
	}
    strcpy(ans, one);
    return ans;
}

序号434

题目：统计字符串中的单词个数，这里的单词指的是连续的不是空格的字符。
请注意，你可以假定字符串里不包括任何不可打印的字符。

解析：

模拟
寻找空格，计入单词

int countSegments(char* s) {
	int cnt = 0;
	int flag = 0;
	for (int i = 0; s[i] != '\0'; ++i)
	{
		if (s[i] != ' ')
		{
			if (flag == 0)
			{
				cnt++;
				flag = 1;
			}
		}
		else
			flag = 0;
	}
	return cnt;
}

序号443

题目：给定一组字符，使用原地算法将其压缩。
压缩后的长度必须始终小于或等于原数组长度。
数组的每个元素应该是长度为1 的字符（不是 int 整数类型）。
在完成原地修改输入数组后，返回数组的新长度。

解析：

双指针
读、写指针以及一个记录起始读的指针。先写字符，再写次数

int compress(char* chars, int charsSize) {
	int read, write, startRead;
	read = write = startRead = 0;

	for (; read < charsSize; ++read)
	{
		if (read + 1 == charsSize || chars[read] != chars[read + 1])
		{
			chars[write++] = chars[startRead];
			if (read > startRead)
			{
				char temp[4] = "";
				sprintf(temp, "%d", read - startRead + 1);
				for (int i = 0; temp[i] != '\0'; ++i)
					chars[write++] = temp[i];
			}
			startRead = read + 1;
		}
	}
	return write;
}

序号520

题目：给定一个单词，你需要判断单词的大写使用是否正确。
我们定义，在以下情况时，单词的大写用法是正确的：
全部字母都是大写，比如"USA"。
单词中所有字母都不是大写，比如"leetcode"。
如果单词不只含有一个字母，只有首字母大写，比如 “Google”。
否则，我们定义这个单词没有正确使用大写字母。

解析：

模拟
用数学翻译题目，大写字母出现 0 次、1次且是首字母、全部都是

bool detectCapitalUse(char * word){
    int cntUp = 0;
    int len = strlen(word);

    for (int i = 0; i < len; ++i)
    {
    	if (isupper(word[i]))
    		cntUp++;
    }
    if (cntUp == len || cntUp == 0 || (cntUp == 1 && isupper(word[0])))
    	return true;
    else
    	return false;
}

序号521

题目：给定两个字符串，你需要从这两个字符串中找出最长的特殊序列。最长特殊序列定义如下：该序列为某字符串独有的最长子序列（即不能是其他字符串的子序列）。
子序列可以通过删去字符串中的某些字符实现，但不能改变剩余字符的相对顺序。空序列为所有字符串的子序列，任何字符串为其自身的子序列。
输入为两个字符串，输出最长特殊序列的长度。如果不存在，则返回 -1。

解析：

逻辑分析
若两个相同，返回 -1
若长度相同且不同，则返回长度
若长度不同，则返回最长的那个，那个必不是另一个的子序列

int findLUSlength(char * a, char * b){
    if (!strcmp(a, b))
        return -1;
    int lenA = strlen(a);
    int lenB = strlen(b);
    return lenA > lenB ? lenA : lenB;
}

序号541

题目：给定一个字符串和一个整数 k，你需要对从字符串开头算起的每个 2k 个字符的前k个字符进行反转。如果剩余少于 k 个字符，则将剩余的所有全部反转。如果有小于 2k 但大于或等于 k 个字符，则反转前 k 个字符，并将剩余的字符保持原样。

解析：
1.模拟
先反转最大 k 个，然后前移 k 个位置

void Reverse(char *str, int left, int right)
{
	int i = left;
	int j = right;
	while (i < j)
	{
		char temp = str[i];
		str[i] = str[j];
		str[j] = temp;
		++i;
		--j;
	}
}
 
char * reverseStr(char * s, int k){
	int len = strlen(s);
	for (int i = 0; i < len;)
	{
		if (i + k < len)
			Reverse(s, i, i + k - 1);
		else
			Reverse(s, i, len - 1);
		i += 2*k;
	}
    return s;
}

序号551

题目：给定一个字符串来代表一个学生的出勤记录，这个记录仅包含以下三个字符：
‘A’ : Absent，缺勤
‘L’ : Late，迟到
‘P’ : Present，到场
如果一个学生的出勤记录中不超过一个’A’(缺勤)并且不超过两个连续的’L’(迟到),那么这个学生会被奖赏。
你需要根据这个学生的出勤记录判断他是否会被奖赏。

解析：

模拟
处理连续的 L，当前是 L，计数 +1；不是，计数归 0

bool checkRecord(char * s){
	int cntA = 0;
	int ctCntL = 0;

	for (int i = 0; s[i] != '\0'; ++i)
	{
		if (s[i] == 'L')
		{
			++ctCntL;
			if (ctCntL > 2)
				return false;
		}
		else
		{
			if (s[i] == 'A')
				++cntA;
			ctCntL = 0;
		}
	}
	if (cntA <= 1)
		return true;
	else
		return false;
}

序号557

题目：给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

解析：

模拟
寻找空格，然后反转单词

void Reverse(char* left, char* right)
{
	while (left < right)
	{
		char temp = *left;
		*left = *right;
		*right = temp;
		++left;
		--right;
	}
}

char* reverseWords(char* s) {
	char* left = s;
	char* right = strchr(s, ' ');
	int len = strlen(s);
	while (right)
	{
		Reverse(left, right - 1);
		left = right + 1;
		right = strchr(left, ' ');
	}
	Reverse(left, s + len - 1);
	return s;
}