面试题5 将一个字符串压缩

题目: 将一个字符串按照下面的方式压缩

字符串 s = "aabccccccaaa"

压缩以后的字符串 s = "a2b1c6a3"

简单说就是讲连续出现的字符按照 字符+连续出现的次数这样压缩

另外 如果按照这样压缩了话 压缩之后的字符串大小比压缩之前的字符串大或者一样 则不要压缩 返回原来的字符串

思路是 先找到压缩之后 有多少个 字母+次数 的组合 然后建立相应大小的 int 型数组 每个奇数位都是相应字母的 ascii 值 偶数为则是出现次数 然后按顺序讲这些值存入 StringBuilder 之后输出

但是这样的做很麻烦 而且更重要的是 很难去判断压缩后的字符串是不是比压缩前的字符串要小

按照上面思路的代码如下 其中判断压缩后字符串的大小很难 代码中其实有错误 但是压缩过程是没有问题的

public String badSolution(String original){
int compressedSize = findCompressedSize(original);

if(compressedSize >= original.length()) return original;

int[] compressed = new int[compressedSize];

int i=0, j=0, letterCounter=1;
int itr = 0;
while(itr<original.length()){
char current = original.charAt(itr);

if(itr==0){
i = 0;
j = i+1;

compressed[i] = current;
letterCounter = 1;
compressed[j] = letterCounter;
itr++;

continue;
}

if(compressed[i]!=current){
i = j+1;
j = i+1;

compressed[i] = current;
letterCounter = 1;
}else{
compressed[j] = ++letterCounter;
}

itr++;
}

return compressedArrayToString(compressed);
}

private int findCompressedSize(String str){
int result = 0;
char previous = '\0';

for(int i=0; i<str.length(); i++){
char current = str.charAt(i);

if(i==0){
result++;
previous = current;
continue;
}

if(previous!=current){
result++;
previous = current;
}
}

return result*2;
}

private String compressedArrayToString(int[] compressed){
if(compressed.length==0)  return null;

StringBuilder result = new StringBuilder();
for(int i=0; i<compressed.length; i++){
if(i%2==0){
char c = (char)compressed[i];
result.append(c);
}else{
result.append((int)compressed[i]);
}
}

return result.toString();
}

该方法的时间复杂度是 O(n) 空间复杂度是 O(n) 因为我们无论如何也要遍历所有字符 所以时间复杂度已经不能提高 另外 由于需要返回新的String 所以空间复杂度也已经无法提高

但是该方法中 countFindCompressSize 其实只能找到有多少 字母+次数 的组合 并不是真的压缩后的大小

按照这样的思路修改代码 简化后的正确代码如下

public String goodSolution(String original){
int size = countCompression(original);
if(size >= original.length())  return original;

char[] array = new char[size];
int index = 0;
char last = original.charAt(0);
int count = 1;

for(int i=1; i<original.length(); i++){
if(original.charAt(i)==last) count++;
else{
index = setChar(array, last, index, count);
last = original.charAt(i);
count = 1;
}
}

index = setChar(array, last, index, count);
return String.valueOf(array);
}

private int countCompression(String str){
if(str==null || str.isEmpty())  return 0;

char last = str.charAt(0);
int size = 0;
int count = 1;

for(int i=1; i<str.length(); i++){
if(str.charAt(i)==last){
count++;
}else{
last = str.charAt(i);
size += 1+String.valueOf(count).length();
count = 1;
}
}

size += 1+String.valueOf(count).length();

return size;
}

private int setChar(char[] array, char c, int index, int count){
array[index++] = c;

char[] cnt = String.valueOf(count).toCharArray();

for(char x:cnt) array[index++] = x;

return index;
}

该方法时间复杂度和空间复杂度和第一个方法一样 但是可以正确的计算压缩后的大小

另外此方法更直观易懂 不加入额外的StringBuilder 此方法是最优解