题解
思路一：反向遍历
class Solution { public int lengthOfLastWord(String s) { int end = s.length() - 1; while (end >= 0 && s.charAt(end) == ' ') end--; if (end == -1) return 0; int start = end; while (start >= 0 && s.charAt(start) != ' ') start--; return end - start; } }
8.最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 " "。
示例
输入：strs = [“flower”,“flow”,“flight”] 输出：“fl”
输入：strs = [“dog”,“racecar”,“car”] 输出：“” 解释：输入不存在公共前缀。
提示：
1 <= strs.length <= 200
0 <= strs[i].length <= 200
strs[i] 仅由小写英文字母组
题解
思路一：暴力法
class Solution { public String longestCommonPrefix(String[] strs) { if (strs == null || strs.length == 0) { return ""; } int length = strs[0].length(); int count = strs.length; for (int i = 0; i < length; i++) { char c = strs[0].charAt(i); for (int j = 1; j < count; j++) { if (i == strs[j].length() || strs[j].charAt(i) != c) { return strs[0].substring(0, i); } } } return strs[0]; } }
上述代码使用了水平扫描法来找到最长公共前缀。以下是该算法的思路：
- 首先，检查输入的字符串数组是否为空或长度为0，如果是的话，直接返回空字符串。
- 初始化变量 length 为第一个字符串的长度，表示最长公共前缀的可能长度。
- 初始化变量 count 为字符串数组的长度，表示需要比较的字符串数量。
- 使用外层循环遍历第一个字符串的每个字符（索引从0到length-1）。
- 在每次循环中，用变量 c 存储当前字符。
- 使用内层循环遍历从第二个字符串到最后一个字符串（索引从1到count-1）。
- 在每次内层循环中，首先检查索引 i 是否超出了字符串的长度，或者当前字符串的字符与第一个字符串的字符不相等，如果是的话，说明当前字符不属于公共前缀，直接返回第一个字符串的子串从索引0到i-1的部分。
- 如果内层循环结束时没有返回，说明当前字符在所有字符串中都相等，继续下一个字符的比较。
- 如果外层循环结束时都没有返回，说明第一个字符串就是最长公共前缀，直接返回第一个字符串。
这种方法通过逐个字符的比较来寻找最长公共前缀，当遇到不相等的字符或字符串长度超出时即可得到结果。
小结
1.判断数组中相同的数，并判断了几次
以下是一个使用Java的示例代码来判断数组中相同的数，并计算它们出现的次数：
import java.util.HashMap; import java.util.Map; public class CountDuplicateNumbers { public static void main(String[] args) { int[] numbers = {1, 2, 3, 4, 5, 1, 3, 2, 4, 1}; Map<Integer, Integer> countMap = new HashMap<>(); for (int num : numbers) { if (countMap.containsKey(num)) { countMap.put(num, countMap.get(num) + 1); } else { countMap.put(num, 1); } } System.out.println("Duplicate numbers and their counts:"); for (Map.Entry<Integer, Integer> entry : countMap.entrySet()) { if (entry.getValue() > 1) { System.out.println(entry.getKey() + " - " + entry.getValue() + " times"); } } } }
这段代码使用了HashMap来存储每个数字及其出现的次数。首先，我们遍历数组中的每个元素，如果countMap中已经包含该数字，则将其对应的值加1；否则，在countMap中添加该数字并设置初始值为1。最后，我们遍历countMap并打印出现次数大于1的数字及其出现次数。
在上述示例中，输入的数组为{1, 2, 3, 4, 5, 1, 3, 2, 4, 1}，输出结果为：
Duplicate numbers and their counts: 1 - 3 times 2 - 2 times 3 - 2 times 4 - 2 times
2.判断数组中两个数的最大差值
以下是使用Java编写的示例代码，用于找到数组中两个数的最大差值：
public class MaxDifference { public static void main(String[] args) { int[] numbers = {2, 5, 9, 3, 1, 12, 6, 8}; int maxDifference = findMaxDifference(numbers); System.out.println("Maximum difference: " + maxDifference); } public static int findMaxDifference(int[] numbers) { if (numbers == null || numbers.length < 2) { throw new IllegalArgumentException("Array must contain at least 2 numbers"); } int minNumber = numbers[0]; int maxDifference = numbers[1] - minNumber; for (int i = 2; i < numbers.length; i++) { if (numbers[i - 1] < minNumber) { minNumber = numbers[i - 1]; } int currentDifference = numbers[i] - minNumber; if (currentDifference > maxDifference) { maxDifference = currentDifference; } } return maxDifference; } }
在上述示例中，我们定义了一个findMaxDifference方法，该方法接受一个整数数组作为输入，并返回数组中两个数的最大差值。首先，我们检查数组是否为空或长度小于2，如果是，则抛出IllegalArgumentException异常。
然后，我们初始化minNumber为数组的第一个元素，将maxDifference初始化为第二个元素减去minNumber。接下来，我们遍历数组从索引2开始的每个元素。如果当前元素之前的最小数字minNumber大于当前元素的前一个元素，则更新minNumber为前一个元素的值。
然后，我们计算当前元素与minNumber之间的差值，并将其存储在currentDifference变量中。如果currentDifference大于maxDifference，则更新maxDifference为currentDifference。
最后，我们返回maxDifference作为结果。
在上述示例中，输入的数组为{2, 5, 9, 3, 1, 12, 6, 8}，输出结果为：
Maximum difference: 11
这表示数组中的最大差值为11，即12减去1。
3.判断后一个数比前一个数的最大差值
以下是使用Java编写的示例代码，用于找到数组中后一个数比前一个数的最大差值：
public class MaxDifference { public static void main(String[] args) { int[] numbers = {2, 5, 9, 3, 1, 12, 6, 8}; int maxDifference = findMaxDifference(numbers); System.out.println("Maximum difference between consecutive numbers: " + maxDifference); } public static int findMaxDifference(int[] numbers) { if (numbers == null || numbers.length < 2) { throw new IllegalArgumentException("Array must contain at least 2 numbers"); } int maxDifference = Integer.MIN_VALUE; for (int i = 1; i < numbers.length; i++) { int currentDifference = numbers[i] - numbers[i - 1]; if (currentDifference > maxDifference) { maxDifference = currentDifference; } } return maxDifference; } }
在上述示例中，我们定义了一个findMaxDifference方法，该方法接受一个整数数组作为输入，并返回数组中后一个数比前一个数的最大差值。首先，我们检查数组是否为空或长度小于2，如果是，则抛出IllegalArgumentException异常。
然后，我们初始化maxDifference为Integer.MIN_VALUE，这是一个较小的初始值，确保可以正确比较和更新最大差值。
接下来，我们遍历数组从索引1开始的每个元素。通过计算当前元素与其前一个元素的差值，并将其存储在currentDifference变量中。如果currentDifference大于maxDifference，则更新maxDifference为currentDifference。
最后，我们返回maxDifference作为结果。
在上述示例中，输入的数组为{2, 5, 9, 3, 1, 12, 6, 8}，输出结果为：
/
Maximum difference between consecutive numbers: 11
这表示数组中后一个数比前一个数的最大差值为11，即12减去1。
4.循环遍历字符串
以下是使用Java编写的示例代码，用于循环遍历字符串并打印每个字符：
public class LoopString { public static void main(String[] args) { String str = "Hello, World!"; // 使用for循环遍历字符串 System.out.println("Using for loop:"); for (int i = 0; i < str.length(); i++) { char ch = str.charAt(i); System.out.println(ch); } // 使用增强型for循环遍历字符串 System.out.println("Using enhanced for loop:"); for (char ch : str.toCharArray()) { System.out.println(ch); } // 使用while循环遍历字符串 System.out.println("Using while loop:"); int index = 0; while (index < str.length()) { char ch = str.charAt(index); System.out.println(ch); index++; } } }
在上述示例中，我们使用三种不同的循环方式来遍历字符串"Hello, World!"。
首先，我们使用for循环来遍历字符串。通过获取字符串的长度str.length()，我们可以使用索引从0到字符串长度减1的范围来依次访问每个字符。使用charAt()方法，我们可以获取指定索引位置的字符，并将其打印出来。
然后，我们使用增强型for循环（也称为foreach循环）来遍历字符串。通过调用toCharArray()方法，我们可以将字符串转换为一个字符数组。这样，我们就可以直接遍历字符数组的每个元素，并将其打印出来。
最后，我们使用while循环来遍历字符串。通过定义一个索引变量index，并在每次迭代后递增它，我们可以依次访问字符串中的每个字符。在循环体中，我们使用charAt()方法获取指定索引位置的字符，并将其打印出来。
以上三种循环方式都会输出相同的结果，即遍历字符串并打印每个字符。
在上述示例中，输出结果为：
Using for loop: H e l l o , W o r l d ! Using enhanced for loop: H e l l o , W o r l d ! Using while loop: H e l l o , W o r l d !
5.判断字符串中的空格符号，并将第一个空格后面设置为第二个字符串，第二个空格为第三个字符串
以下是使用Java编写的示例代码，用于判断字符串中的空格符号，并将第一个空格后面的内容设置为第二个字符串，第二个空格后面的内容设置为第三个字符串：
public class SplitString { public static void main(String[] args) { String str = "Hello, World! This is a test."; // 使用split()方法分割字符串 String[] parts = str.split("\\s+", 3); if (parts.length >= 3) { String firstString = parts[0]; String secondString = parts[1]; String thirdString = parts[2]; System.out.println("First string: " + firstString); System.out.println("Second string: " + secondString); System.out.println("Third string: " + thirdString); } else { System.out.println("The input string does not contain enough spaces."); } } }
在上述示例中，我们首先定义了一个输入字符串"Hello, World! This is a test."。
然后，我们使用split()方法对输入字符串进行分割。split()方法以指定的正则表达式作为分隔符来拆分字符串。在这里，我们使用正则表达式\\s+，表示一个或多个连续的空白字符（包括空格、制表符、换行符等）作为分隔符。第二个参数3表示最大分割成三部分。
接下来，我们检查分割后的结果数组parts的长度是否大于等于3。如果是，则表示输入字符串中至少有两个空格符号。
然后，我们提取数组parts中的第一个、第二个和第三个元素作为相应的字符串变量：firstString、secondString和thirdString。
最后，我们打印输出每个字符串的内容。
在上述示例中，输出结果为：
First string: Hello, Second string: World! Third string: This is a test.
这表示输入字符串中的第一个空格后面的内容被设置为第二个字符串（“World!”），第二个空格后面的内容被设置为第三个字符串（“This is a test.”）。
