markilue
/
self_example
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

leecode更新

This commit is contained in:
dingjiawen 2022-09-09 15:02:46 +08:00
parent 0eb1de8bcf
commit 48fa58f8f2
3 changed files with 314 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
Leecode/src/main/java/com/markilue/leecode/string/ReverseStr.java Normal file
View File

@ -0,0 +1,147 @@
package com.markilue.leecode.string;
import org.junit.Test;
/**
* @BelongsProject: Leecode
* @BelongsPackage: com.markilue.leecode.string
* @Author: dingjiawen
* @CreateTime: 2022-09-09 10:16
* @Description: TODO 力扣541题 反转字符串II:
* 给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
* 1)如果剩余字符少于 k 个，则将剩余字符全部反转。
* 2)如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
* @Version: 1.0
*/
public class ReverseStr {
@Test
public void test() {
String s = "abcdefghij";
int k = 3;
String s1 = reverseStr(s, k);
System.out.println(s1);
}
@Test
public void test1() {
String s = "abcd";
int k = 2;
String s1 = reverseStr(s, k);
System.out.println(s1);
}
@Test
public void test2() {
String s = "hyzqyljrnigxvdtneasepfahmtyhlohwxmkqcdfehybknvdmfrfvtbsovjbdhevlfxpdaovjgunjqlimjkfnqcqnajmebeddqsgl";
int k = 39;
String s1 = reverseStr(s, k);
System.out.println(s1);
}
@Test
public void test3() {
String s = "abcdefg";
int k = 39;
String s1 = reverseStr(s, k);
System.out.println(s1);
}
/**
* 本人的思路:fori一下，i步长为2k,2k内部就自己进行交换；for完之后判断i==length还是i<length-k还是i<length-2k做最后的处理
* 速度击败5.11%，内存击败8.84%
*
* @param s
* @param k
* @return
*/
public String reverseStr(String s, int k) {
char[] chars = s.toCharArray();
int i = 0;
if (chars.length > 2 * k) {
//留下最后2k以内的范围单独处理,因为要分情况单独处理
for (; i < chars.length - 2 * k; i += 2 * k) {
int z = i;
//前k个字母反转:i和i+k-1交换
while (z < i + k / 2) {
exchange(chars, z, i + k - 1 - z + i);
z++;
}
}
}
//出来以后判断是从什么条件出来的
if (i >= chars.length - k) {
//剩下的长度<k
//有多少交换多少
int z = i;
while (z < i + (chars.length - i) / 2) {
exchange(chars, z, chars.length - 1 - z + i);
z++;
}
} else if (i >= chars.length - 2 * k) {
//剩下的长度<2k
//交换前k个
int z = i;
while (z < i + k / 2) {
exchange(chars, z, i + k - 1 - z + i);
z++;
}
}
String result = "";
for (char aChar : chars) {
result += aChar;
}
return result;
}
/**
* 官方的思路:与本人的类似，但是不用留下剩下的做判断,都把他视作交换全部的一部分，只不过是左右范围不同
* 速度击败100%，内存击败35%
*
* @param s
* @param k
* @return
*/
public String reverseStr1(String s, int k) {
char[] chars = s.toCharArray();
//均是交换，只不过是交换的范围不同，这样就可以不用分头处理了
for (int i = 0; i < chars.length; i += 2 * k) {
reverse(chars,i,Math.min(i+k,chars.length)-1);
}
return new String(chars);
}
public void reverse(char[] chars,int left,int right){
while (left<right){
char temp =chars[left];
chars[left]=chars[right];
chars[right]=temp;
left++;
right--;
}
}
//交换数组中的两个元素
public void exchange(char[] s, int i, int j) {
char temp = s[i];
s[i] = s[j];
s[j] = temp;
}
}

63
Leecode/src/main/java/com/markilue/leecode/string/ReverseString.java Normal file
View File

@ -0,0 +1,63 @@
package com.markilue.leecode.string;
import org.junit.Test;
/**
* @BelongsProject: Leecode
* @BelongsPackage: com.markilue.leecode.string
* @Author: dingjiawen
* @CreateTime: 2022-09-09 09:30
* @Description:
* TODO 力扣344题 反转字符串:
* 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
* 不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
*
* @Version: 1.0
*/
public class ReverseString {
@Test
public void test(){
char[] s = {'h', 'e', 'l', 'l', 'o'};
reverseString(s);
char[] c = {'H','a','b','n','a','h'};
reverseString(c);
}
@Test
public void test1(){
char[] s = {'A',' ','m','a','n',',',' ','a',' ','p','l','a','n',',',' ','a',' ','c','a','n','a','l',':',' ','P','a','n','a','m','a'};
reverseString(s);
}
/**
* 自己的思路:由于不让给数组分配另外的空间，因此考虑使用前后交换法，找到数组的中间然后前后交换
* 速度击败100% 内存击败24.24%
* @param s
*/
public void reverseString(char[] s) {
if (s.length<=1) {
return;
}
for (int i = 0; i < s.length / 2; i++) {
exchange(s,i, s.length-1-i);
}
// System.out.println(s.toString());
System.out.println(s);
}
//交换数组中的两个元素
public void exchange(char[] s,int i,int j){
char temp=s[i];
s[i]=s[j];
s[j]=temp;
}
}

104
Leecode/src/main/java/com/markilue/leecode/string/ReverseWords.java Normal file
View File

@ -0,0 +1,104 @@
package com.markilue.leecode.string;
import org.junit.Test;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;
/**
* @BelongsProject: Leecode
* @BelongsPackage: com.markilue.leecode.string
* @Author: dingjiawen
* @CreateTime: 2022-09-09 12:12
* @Description: TODO 力扣151题：反转字符串中的单词:
* 给你一个字符串 s ，请你反转字符串中 单词 的顺序。
* 单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
* 返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
* 注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
* @Version: 1.0
*/
public class ReverseWords {
@Test
public void test() {
String s = " hello world ";
String s1 = reverseWords(s);
System.out.println(s1);
}
@Test
public void test1() {
String s = " the sky is blue ";
String s1 = reverseWords(s);
System.out.println(s1);
}
/**
* 速度超过12%，内存超过5%
* @param s
* @return
*/
public String reverseWords(String s) {
String[] s1 = s.split(" ");
String result = "";
for (int i = s1.length - 1; i >= 0; i--) {
if (!"".equals(s1[i]) ) {
result += s1[i] + " ";
}
}
return result.trim();
}
/**
* 速度超过12%，内存超过5%
* @param s
* @return
*/
public String reverseWords1(String s) {
String[] s1 = s.trim().split(" ");
String result = "";
for (int i = s1.length - 1; i >= 0; i--) {
if (!"".equals(s1[i]) ) {
if(i==0){
result += s1[i];
}else {
result += s1[i] + " ";
}
}
}
return result;
}
/**
* 官方使用API的代码
* 速度超过12%，内存超过5%
* @param s
* @return
*/
public String reverseWords2(String s) {
// 除去开头和末尾的空白字符
s = s.trim();
// 正则匹配连续的空白字符作为分隔符分割
List<String> wordList = Arrays.asList(s.split("\\s+"));
Collections.reverse(wordList);
return String.join(" ", wordList);
}
}