代码随想录算法训练营_day08

{{day08}}

Java 中字符串和数组的差别

1. 定义和本质

字符串 (String)

  • 字符串在 Java 中是一个对象,是 java.lang.String 类的实例。
  • 字符串实际上是一个字符数组的封装,但提供了更多的方法和功能。
  • 字符串是不可变的(immutable),一旦创建就不能修改其内容。

数组 (Array)

  • 数组是一种用于存储多个相同类型元素的容器。
  • 数组是 Java 中的一种引用类型。
  • 数组可以存储基本数据类型(如 int, char)或对象。
  • 数组的大小是固定的,一旦创建就不能改变其长度。

2. 创建方式

字符串

String str1 = "Hello";  // 字面量创建
String str2 = new String("Hello");  // 使用构造函数

数组

int[] arr1 = new int[5];  // 创建指定大小的数组
int[] arr2 = {1, 2, 3, 4, 5};  // 使用初始化列表

3. 可变性

字符串

  • 不可变:一旦创建,内容不能被改变。
  • 每次"修改"字符串实际上是创建了一个新的字符串对象。

数组

  • 可变:创建后可以修改其元素的值。
  • 但数组的大小是固定的,不能增加或减少元素。

4. 操作和方法

字符串

  • 提供了丰富的内建方法,如 length()substring()charAt()equals() 等。
  • 支持连接操作(+)。

数组

  • 基本操作如访问元素(使用索引)、修改元素。
  • 没有内建方法,但可以使用 java.util.Arrays 类的静态方法进行操作。

题目信息 344. 反转字符串

  • 题目链接: https://leetcode.cn/problems/reverse-string/description/
  • 题目描述: 编写一个函数,其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

解法一: {{双指针——交换}}

解题思路

对于字符串,我们定义两个指针(也可以说是索引下标),一个从字符串前面,一个从字符串后面,两个指针同时向中间移动,并交换元素。

以字符串hello为例,过程如下:
![[344.反转字符串.gif]]

代码实现

public void reverseString(char[] s) {  
    int left = 0;  
    int right = s.length - 1;  
    while (left < right){  
        char temp = s[left];  
        s[left] = s[right];  
        s[right] = temp;  
        left++;  
        right--;  
    }  
}

解法二: {{双指针——异或交换}}

解题思路

异或运算的一些重要性质:

  1. a ^ a = 0 (任何数与自身异或等于0)
  2. a ^ 0 = a (任何数与0异或等于它本身)
  3. a ^ b = b ^ a (交换律)
  4. (a ^ b) ^ c = a ^ (b ^ c) (结合律)
    另外,异或运算是可逆的。如果 a ^ b = c,那么 c ^ b = a 和 c ^ a = b。

步骤1:s[l] ^= s[r]

这一步相当于 s[l] = s[l] ^ s[r],即 s[l] = a ^ b。 此时,s[l] = a ^ b,s[r] = b

步骤2:s[r] ^= s[l]

这一步相当于 s[r] = s[r] ^ s[l],即 s[r] = b ^ (a ^ b)。 根据异或的性质,b ^ (a ^ b) = (b ^ b) ^ a = 0 ^ a = a 此时,s[l] = a ^ b,s[r] = a

步骤3:s[l] ^= s[r]

这一步相当于 s[l] = s[l] ^ s[r],即 s[l] = (a ^ b) ^ a。 根据异或的性质,(a ^ b) ^ a = b 此时,s[l] = b,s[r] = a

至此,s[l] 和 s[r] 的值已经成功交换。

代码实现

    public void reverseString(char[] s) {
        int l = 0;
        int r = s.length - 1;
        while (l < r) {
            s[l] ^= s[r];  //构造 a ^ b 的结果,并放在 a 中
            s[r] ^= s[l];  //将 a ^ b 这一结果再 ^ b ,存入b中,此时 b = a, a = a ^ b
            s[l] ^= s[r];  //a ^ b 的结果再 ^ a ,存入 a 中,此时 b = a, a = b 完成交换
            l++;
            r--;
        }
    }

题目信息541. 反转字符串 II

  • 题目链接: https://leetcode.cn/problems/reverse-string-ii/description/

  • 题目描述: 给定一个字符串 s 和一个整数 k,从字符串开头算起,每计数至 2k 个字符,就反转这 2k 字符中的前 k 个字符。

  • 如果剩余字符少于 k 个,则将剩余字符全部反转。

  • 如果剩余字符小于 2k 但大于或等于 k 个,则反转前 k 个字符,其余字符保持原样。

解法一:

代码实现

public String reverseStr(String s, int k) {  
    // 将字符串转换为字符数组  
    char[] ch = s.toCharArray();  
    for (int i = 0;i < ch.length;i += 2*k){  
            int start = i;  
            int end = Math.min(ch.length - 1,start + k - 1);  
            while (start < end){  
                char temp = ch[start];  
                ch[start] = ch[end];  
                ch[end] = temp;  
                start++;  
                end--;  
            }  
    }  
    return new String(ch);  
}

解法二:

代码实现

public String reverseStr(String s, int k) {
        StringBuffer res = new StringBuffer();
        int length = s.length();
        int start = 0;
        while (start < length) {
            // 找到k处和2k处
            StringBuffer temp = new StringBuffer();
            // 与length进行判断,如果大于length了,那就将其置为length
            int firstK = (start + k > length) ? length : start + k;
            int secondK = (start + (2 * k) > length) ? length : start + (2 * k);

            //无论start所处位置,至少会反转一次
            temp.append(s.substring(start, firstK));
            res.append(temp.reverse());

            // 如果firstK到secondK之间有元素,这些元素直接放入res里即可。
            if (firstK < secondK) { //此时剩余长度一定大于k。
                res.append(s.substring(firstK, secondK));
            }
            start += (2 * k);
        }
        return res.toS

解法三: 异或

代码实现

    public String reverseStr(String s, int k) {
        char[] ch = s.toCharArray();
        for(int i = 0; i < ch.length; i += 2 * k){
            int start = i;
            //这里是判断尾数够不够k个来取决end指针的位置
            int end = Math.min(ch.length - 1, start + k - 1);
            //用异或运算反转 
            while(start < end){
                ch[start] ^= ch[end];
                ch[end] ^= ch[start];
                ch[start] ^= ch[end];
                start++;
                end--;
            }
        }
        return new String(ch);
    }

题目信息 卡码网54. 替换数字(第八期模拟笔试)

  • 题目链接: https://kamacoder.com/problempage.php?pid=1064
  • 题目描述:给定一个字符串 s,它包含小写字母和数字字符,请编写一个函数,将字符串中的字母字符保持不变,而将每个数字字符替换为number。 例如,对于输入字符串 “a1b2c3”,函数应该将其转换为 “anumberbnumbercnumber”。

解题思路

首先扩充数组到每个数字字符替换成 “number” 之后的大小。

例如 字符串 “a5b” 的长度为3,那么 将 数字字符变成字符串 “number” 之后的字符串为 “anumberb” 长度为 8。

如图:

代码随想录算法训练营_day08_第1张图片

然后从后向前替换数字字符,也就是双指针法,过程如下:i指向新长度的末尾,j指向旧长度的末尾。

代码随想录算法训练营_day08_第2张图片

有同学问了,为什么要从后向前填充,从前向后填充不行么?

从前向后填充就是O(n^2)的算法了,因为每次添加元素都要将添加元素之后的所有元素整体向后移动。

其实很多数组填充类的问题,其做法都是先预先给数组扩容带填充后的大小,然后在从后向前进行操作。

这么做有两个好处:

  1. 不用申请新数组。
  2. 从后向前填充元素,避免了从前向后填充元素时,每次添加元素都要将添加元素之后的所有元素向后移动的问题。

代码实现(一)

public static void main(String[] args) {  
    Scanner in = new Scanner(System.in);  
    String s = in.nextLine();  
    StringBuilder sb = new StringBuilder();  
    for (int i = 0; i < s.length(); i++) {  
        if (Character.isDigit(s.charAt(i))) {  
            sb.append("number");  
        }else sb.append(s.charAt(i));  
    }  
    System.out.println(sb);  
}

代码实现(二)

public static void main(String[] args) {  
    Scanner sc = new Scanner(System.in);  
    String s = sc.next();  
    int len = s.length();  
    for (int i = 0; i < s.length(); i++) {  
        if (s.charAt(i) >= 0 && s.charAt(i) <= '9') {  
            len += 5;  
        }  
    }  
  
    char[] ret = new char[len];  
    for (int i = 0; i < s.length(); i++) {  
        ret[i] = s.charAt(i);  
    }  
    for (int i = s.length() - 1, j = len - 1; i >= 0; i--) {  
        if ('0' <= ret[i] && ret[i] <= '9') {  
            ret[j--] = 'r';  
            ret[j--] = 'e';  
            ret[j--] = 'b';  
            ret[j--] = 'm';  
            ret[j--] = 'u';  
            ret[j--] = 'n';  
        } else {  
            ret[j--] = ret[i];  
        }  
    }  
    System.out.println(ret);  
}

你可能感兴趣的:(代码随想录算法训练营,算法,python,开发语言)