【无标题】

力扣第20题-有效的次数

题目描述

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

有效字符串需满足：

• 左括号必须用相同类型的右括号闭合。

• 左括号必须以正确的顺序闭合。

• 每个右括号都有一个对应的相同类型的左括号。

• 示例 1：

输入：s = “()”
输出：true

• 示例 2：

输入：s = “()[]{}”
输出：true

• 示例 3：

输入：s = “(]”
输出：false

• 提示：

• 1 <= s.length <= 104
• s 仅由括号 ‘()[]{}’ 组成

代码及思路

代码如下

bool isValid(char *s) {
    int top = -1;  
    char stack[10001];  

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

    return top == -1;  
}

思路
首先声明一个栈顶指针，初始化为-1，这是为了让后面入栈的时候自增为0成为栈中第一个元素。然后进入循环，将（，[，{，左括号存放在栈里，当循环指到右括号时，将第一个右括号与栈里最后一个左括号匹配，依次进行，最后在判断top是否等于原来的-1，若top=-1，则return true,否则，return false.

力扣第2810题-故障键盘

题目描述

你的笔记本键盘存在故障，每当你在上面输入字符 ‘i’ 时，它会反转你所写的字符串。而输入其他字符则可以正常工作。

给你一个下标从 0 开始的字符串 s ，请你用故障键盘依次输入每个字符。

返回最终笔记本屏幕上输出的字符串。

• 示例 1：

输入：s = “string”
输出：“rtsng”
解释：
输入第 1 个字符后，屏幕上的文本是：“s” 。
输入第 2 个字符后，屏幕上的文本是：“st” 。
输入第 3 个字符后，屏幕上的文本是：“str” 。
因为第 4 个字符是 ‘i’ ，屏幕上的文本被反转，变成 “rts” 。
输入第 5 个字符后，屏幕上的文本是：“rtsn” 。
输入第 6 个字符后，屏幕上的文本是： “rtsng” 。
因此，返回 “rtsng” 。

• 示例 2：

输入：s = “poiinter”
输出：“ponter”
解释：
输入第 1 个字符后，屏幕上的文本是：“p” 。
输入第 2 个字符后，屏幕上的文本是：“po” 。
因为第 3 个字符是 ‘i’ ，屏幕上的文本被反转，变成 “op” 。
因为第 4 个字符是 ‘i’ ，屏幕上的文本被反转，变成 “po” 。
输入第 5 个字符后，屏幕上的文本是：“pon” 。
输入第 6 个字符后，屏幕上的文本是：“pont” 。
输入第 7 个字符后，屏幕上的文本是：“ponte” 。
输入第 8 个字符后，屏幕上的文本是：“ponter” 。
因此，返回 “ponter” 。

• 提示：

• 1 <= s.length <= 100
• s 由小写英文字母组成
• s[0] != ‘i’

代码及思路

代码

void r(char *str,int start,int end)
{  
    while(start < end) {  
        char temp=str[start];  
        str[start]=str[end];  
        str[end]=temp;  
        start++;  
        end--;  
    }  
}
char* finalString(char* s)
{
    int len=strlen(s);
    char *result=(char *)malloc(sizeof(char)*(len+1));
    int index=0;
    for(int i=0;i<len;i++)
    {
        if(s[i] == 'i')
…            r(result,0,index-1);
        }
        else
        {
            result[index++]=s[i];
        }
    }
    result[index]='\0';
    return result;
}

思路

先分配一个新内存，用来存要返回的新数组result，遍历原来数组每个元素，当不是’i’时，把它直接存放在新数组里，当是i时，把它之前的数组倒序，最后返回这个新数组。

力扣第58题-最后一个单词个数

题目描述：

给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。

单词 是指仅由字母组成、不包含任何空格字符的最大
子字符串
。

示例 1：

输入：s = “Hello World”
输出：5
解释：最后一个单词是“World”，长度为5。
示例 2：

输入：s = " fly me to the moon "
输出：4

代码及思路

代码

int lengthOfLastWord(char * s)
{
    int i = 0;
    int n = 0;

    while(s[i] != '\0')
    {
        if(s[i] != ' ')
        {
            if ((i > 0) && (s[i - 1] == ' '))
            {
                n = 0;
            }

            n++;
        }
        
        i++;
    }

    return n;
    }

思路
首先用一个while循环从前往后依次遍历每一个单词，当这个单词不是此单词的首字母，n++来统计此单词个数，当这个单词是首字母时，令n=0,重新来统计。if ((i > 0) && (s[i - 1] == ’ '))，这个是用来判断此单词是不是此单词的首字母。特殊的是，当n=0，虽然不满足if条件，但会i++，继续满足条件，进入条件。

力扣第14题-最长公共前缀

题目描述

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

• 示例 1：

输入：strs = [“flower”,“flow”,“flight”]
输出：“fl”

• 示例 2：

输入：strs = [“dog”,“racecar”,“car”]
输出：“”
解释：输入不存在公共前缀。

• 提示：

1 <= strs.length <= 200
0 <= strs[i].length <= 200
strs[i] 仅由小写英文字母组成

代码及思路

代码如下

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

思路：
利用一个二维数组，将第一个字符串str[0]作为标杆，利用for循环，依次将第一个字符串中的各个元素与后面几个字符串相对应的各个元素相比较，如果不相等，则令str[0][i]=‘\0’，最后返回此时的第一个字符串。

力扣第21题-合并两个有序链表

题目描述

21. 合并两个有序链表
    将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2：

输入：l1 = [], l2 = []
输出：[]
示例 3：

输入：l1 = [], l2 = [0]
输出：[0]

提示：

两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列

代码及思路

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
    if(!list1){
        return list2;
    }
    if(!list2){
        return list1;
    }
    struct ListNode *L = (struct ListNode *)malloc(sizeof(struct ListNode));
    struct ListNode *p1 = list1, *p2 = list2; 
    struct ListNode *s = L;
    while(p1 && p2){
        if(p1->val <= p2->val){
            s->next = p1;
            s = p1;
            p1 = p1->next;
        }
        else{
           s->next = p2; 
           s = p2; 
           p2 = p2->next;
        }
    }
    if(!p1){
        s->next = p2; 
    }
    if(!p2){
        s->next = p1;
    } 
    return L->next;
}

思路
首先创作一个新的链表来存放数据，判断list1与list2是否为0，否则直接输出另一个，再判断P1和P2的大小，最后当不满足while条件，如果P1完了，则剩余的P2直接输出即可，反之。

力扣第217-存在重复元素

题目

给你一个整数数组 nums 。如果任一值在数组中出现 至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false 。

示例 1：

输入：nums = [1,2,3,1]
输出：true
示例 2：

输入：nums = [1,2,3,4]
输出：false
示例 3：

输入：nums = [1,1,1,3,3,4,3,2,4,2]
输出：true

提示：

1 <= nums.length <= 105
-109 <= nums[i] <= 109

代码及思路

代码

bool containsDuplicate(int* nums, int numsSize) {
    	int* arr=(int*)malloc(100*sizeof(int));
	int i,j;
	int x=0;
    int cnt=0;
	for(i=0;i!='\n';i++){
		scanf("%d",&arr[i]);
        cnt++;
	}
	for(i=0;i<cnt;i++){
	    for(j=0;j<cnt;j++){
			if(arr[i]==arr[j])
			  x++;
		}
	}
		if(x==1){
			printf("false");
		}else 
		printf("true");
return 0;
}
}

思路
在对数字从小到大排序之后，数组的重复元素一定出现在相邻位置中。因此，我们可以扫描已排序的数组，每次判断相邻的两个元素是否相等，如果相等则说明存在重复的元素。