面试题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 此方法是最优解

转载于:https://www.cnblogs.com/moechen/p/5074822.html