论String操作时间复杂度

面试题
以下类中,method1和method2的时间复杂度一样吗?为什么。

public class Test {
public static final int MB = 1024 * 1024;
public static final long TIMES = 500000000L;

public static void main(String[] args) throws InterruptedException {
method1();
method2();
}
//从字节码来看,method1重复new StringBuilder
然后append,显然不高效。这里排除jit优化。
public static void method1() {
String s = "";
for (int i = 0; i < 100; i++) {
s += "a";
}

System.out.println(s);
}

public static void method2() {
// //b
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++) {
sb.append("a");
}
System.out.println(sb.toString());
}

}

我当时的回答是应该一样,因为我实在找不出说明他们不一样的地方。但是面试官这么问肯定有原因的,我只是从效率方面来分析,比如说method1会通过StringBuilder来做,没有后面method2好。后来面试官纠正了提问,说从时间复杂度来考虑。我直接跟他说了,我只能看出是一样的,可能method2会更好些。面试官好像不是很满意。

回来我从源码着手看,感觉不靠谱,后来看到有人分析用字节码来看。可以看到编译器怎么翻译的。经过证实,跟我的想法一样。字节码如下:

Compiled from "Test.java"
public class Test extends java.lang.Object{
public static final int MB;

public static final long TIMES;

public Test();
Code:
0: aload_0
1: invokespecial #16; //Method java/lang/Object."<init>":()V
4: return

public static void main(java.lang.String[]) throws java.lang.InterruptedException;
Code:
0: invokestatic #27; //Method method1:()V
3: invokestatic #30; //Method method2:()V
6: return

public static void method1();
Code:
0: ldc #35; //String
2: astore_0
3: iconst_0
4: istore_1
5: goto 31
8: new #37; //class java/lang/StringBuilder
11: dup
12: aload_0
13: invokestatic #39; //Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
16: invokespecial #45; //Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
19: ldc #48; //String a
21: invokevirtual #50; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
24: invokevirtual #54; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
27: astore_0
28: iinc 1, 1
31: iload_1
32: bipush 100
34: if_icmplt 8
37: getstatic #58; //Field java/lang/System.out:Ljava/io/PrintStream;
40: aload_0
41: invokevirtual #64; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
44: return

public static void method2();
Code:
0: new #37; //class java/lang/StringBuilder
3: dup
4: invokespecial #73; //Method java/lang/StringBuilder."<init>":()V
7: astore_0
8: iconst_0
9: istore_1
10: goto 23
13: aload_0
14: ldc #48; //String a
16: invokevirtual #50; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
19: pop
20: iinc 1, 1
23: iload_1
24: bipush 100
26: if_icmplt 13
29: getstatic #58; //Field java/lang/System.out:Ljava/io/PrintStream;
32: aload_0
33: invokevirtual #54; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
36: invokevirtual #64; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
39: return

}
### Java 中数组排序的时间复杂度 #### 冒泡排序 冒泡排序是一种简单的排序算法,通过重复地遍历要排序的列表,依次比较相邻元素并交换顺序不对的元素位置。对于给定的一个长度为 \(n\) 的数组,该方法需要两重嵌套循环来完成整个过程。 在外层循环中,每一轮迭代都会使最大的未排序元素“浮上”至其正确的位置;内层循环负责实际的比较与可能发生的交换操作。因此,在最坏的情况下——当输入数据完全逆序时,此算法需执行大约 \(\frac{n(n-1)}{2}\) 次比较和最多同样数量级次数的数据移动[^1]。这表明冒泡排序具有 O\(n^2\) 的时间复杂度。 ```java public static void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - i - 1; j++) { if (arr[j] > arr[j + 1]) { // Swap elements int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } ``` #### 插入排序 插入排序的工作原理类似于人们整理手中的扑克牌。它构建有序序列的过程是从第二个元素开始向前扫描已有的部分,并找到合适的地方将其插入进去。如果待排序列已经接近于升序,则效率较高;但在最差情形下(如初始状态为降序),每一项都需要被移回原处之前的所有位置,从而导致性能下降到 O\(n^2\)[^2]。 ```java // Insertion Sort implementation not shown here but mentioned in the reference. ``` #### 基数排序 基数排序基于多关键字分类的思想实现非比较型整数排序法之一。具体来说,它是按照低位先处理的方式逐位对数字进行分组排列直到最高位为止。由于每次分配都涉及线性扫描所有记录加上重新组装结果集的操作,总体而言,它的运行时间为 O\(kn\) ,这里 k 表示数值的最大位宽或字符数目[^3]。 ```java // Radix Sort implementation details omitted as per provided references. ``` #### 归并排序与快速排序 这两种都是高效的对比类内部排序方式,它们利用了递归分解问题规模的方法论。特别是快速排序以其平均情况下良好的表现而闻名,尽管存在极端条件下退化成平方级别的风险。相比之下,归并排序则始终保持着稳定且可预测的 O\(n log n\) 性能特征[^4]。 ```java // Merge and Quick Sort implementations are typically recursive algorithms that divide arrays into smaller parts before sorting them individually then merging back together or partitioning around a pivot element respectively. ``` #### 希尔排序 希尔排序是对简单插入排序的一种改进版本,也称为缩小增量排序。它不是按单一间隔逐步调整元素之间的相对次序,而是采用多个不同的步长来进行预排序工作,最终使得全局范围内的无序程度大大降低后再应用标准形式下的直接插入技术加以完善。这种策略有效地减少了不必要的远距离跳跃动作,提高了整体速度。然而,确切的时间消耗取决于所选增量序列的选择,通常介乎 O\(n^{1.5}\) 到 O\(n(log_2n)^2\) 不等之间[^5]。 ```java import java.util.Arrays; public class ShellSortExample { public static void main(String[] args) { int[] arrayToBeSorted = {2, 1, 5, 7, 4, 13, 66, 34}; shellSort(arrayToBeSorted); System.out.println(Arrays.toString(arrayToBeSorted)); } private static void shellSort(int[] data) { for (int gap = data.length / 2; gap > 0; gap /= 2) { for (int i = gap; i < data.length; ++i) { final int currentElement = data[i]; int position = i; while ((position >= gap) && (data[position - gap] > currentElement)) { data[position] = data[position - gap]; position -= gap; } data[position] = currentElement; } } } } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值