数据结构之字符串

　　第一篇：数据结构之链表

　　第二篇：数据结构之栈和队列

　　第三篇：数据结构之二叉树

　　第四篇：数据结构之排序

　　在这篇文章里，我们关注和字符串相关的话题。

　　在谈论到字符串时，通常情况下，我们是在讨论ASCII码范围内的字符串，即它包括256个字符。在设计字符串相关的算法时，我们需要在时间和空间这两者之间进行权衡。

　　下面我们来看相关的题目。

• 判断字符串里出现的字符是否是唯一的。
  思路：方案一：将字符串转换为字符数组，从第一个字符开始遍历，针对每个字符，判断字符串之前是否出现过该字符，如果出现过，说明该字符在字符串中不是唯一的。对应的空间复杂度O(1)，时间复杂度O(n*n)。
  

  public static boolean Check(String value)
  {
      if (value == null || value.length() < 2) return true;
      char[] arrChars = value.toCharArray();
      for (int i = 1; i < arrChars.length; i++)
      {
          char ch = arrChars[i];
          for (int j = 0; j < i; j++)
          {
              if (arrChars[j] == ch) return false;
          }
      }
      
      return true;
  }

  方案二：如果字符串中的字符都是ASCII码，那么可以建立一个长度为256的整型flag数组，数组的每个元素初始值是0， 然后遍历字符串，将每个字符对应的ASCII码求出数组中对应位置的元素值，如果为0，说明字符串中暂时还没有出现该字符，将数组对应元素的值设置为1；如果为1，说明字符串中已经出现了该字符，有重复。

  public static boolean Check2(String value)
  {
      if (value == null || value.length() < 2) return true;        
      char[] arrChars = value.toCharArray();
      int[] arrFlag = new int[256];
      for(int flag : arrFlag) flag = 0;
      for(char ch : arrChars)
      {
          if (arrFlag[(int)ch] == 1) return false;
          arrFlag[(int)ch] = 1;
      }
      return true;
  }

  方案三：如果字符串空字符超出ASCII码，那么可以使用一个hashtable来模拟flag数组，将遍历过的每个字符以键的方式插入到hashtable中。代码略。

• 反转字符串
  思路：循环替换（0-n/2），需要注意字符串的最后一位是否是'\0'。
  

  public static String reverse(String value)
  {
      if (value == null || value.length() < 3) return value;
      
      char[] arrChars = value.toCharArray();
      int length = value.length() - 1;
      for (int i = 0; i < length/2; i++)
      {
          char temp = arrChars[i];
          arrChars[i] = arrChars[length - i];
          arrChars[length - i] = temp;
      }
      arrChars[length] = '0';
      return arrChars.toString();
  }

• 删除字符串中的重复字符
  思路：这个题目，同样有遍历和flag数组两种方式。首先来看遍历方式，时间复杂度是O(n*n)，空间复杂度是O(1)。
  

  public static void removeDuplicate2(String value)
  {
      if (value == null || value.length() < 2) return;
      char[] arrChars = value.toCharArray();
      int current = 0;
      for (int i = 1; i < arrChars.length; i++)
      {
          int j = 0;
          for (j = 0; j < i; j++)
          {
              if (arrChars[i] == arrChars[j]) break;
          }
          if (i == j) 
          {
              arrChars[current] = arrChars[i];
              current++;
          }
      }
      arrChars[current] = '0';
      value = arrChars.toString();
  }

  接着是使用flag数组。

  public static void removeDuplicate3(String value)
  {
      if (value == null || value.length() < 2) return;
      int[] arrFlag = new int[256];
      for(int flag : arrFlag) flag = 0;
      char[] arrChars = value.toCharArray();
      int current = 0;
      for (int i = 0; i < arrChars.length; i++)
      {
          if (arrFlag[(int)arrChars[i]] != 1)
          {
              arrChars[current] = arrChars[i];
              arrFlag[(int)arrChars[i]] = 1;
              current++;
          }
      }
      arrChars[current] = '0';
      value = arrChars.toString();
  }

• 判断给定的两个字符串是否是变位词（包含的字符相同，但顺序不同）
  思路：方案一：对两个字符串分别进行排序处理，然后比较排序后的两个字符串是否相同。代码略
  方案二：采用flag数组，首先遍历第一个字符串，填充flag数组；然后遍历第二个字符串，同时检查flag数组。
  

  public static boolean isAnagram(String value1, String value2)
  {
      if (value1 == null || value2 == null || value1.length() != value2.length())
          return false;
      
      int[] arrFlag = new int[256];
      for(int flag : arrFlag) flag = 0;
      char[] arrChars1 = value1.toCharArray();
      for(char ch : arrChars1) arrFlag[ch]++;
      char[] arrChars2 = value2.toCharArray();
      for(char ch : arrChars2) 
      {
          if (arrChars1[ch] == 0)
              return false;
          arrChars1[ch]--;
      }
      return true;
  }

• 将字符串中出现的所有空格替换为'%20'
  思路：由于空格和'%20'长度不一致，这样替换后的字符串长度和原来的长度肯定不一样，对于这种情况，我们需要首先遍历一次字符串，计算出空格的数组，这样也就可以计算出新的字符串的长度，然后从后向前依次替换。
  

  public static void replaceWhitespace(String value)
  {
      if (value == null)return;
      int count = 0;
      for(int i = 0; i < value.length(); i++)
      {
          if (value.charAt(i) == ' ')
          {
              count++;
          }
      }
      if (count == 0) return;
      int length = value.length() + 2 * count;
      int current = length -1;
      char[] arrChars = new char[length];
      for (int i = value.length() - 1; i >= 0; i--)
      {
          if (value.charAt(i) == ' ')
          {
              arrChars[current] = '0';
              arrChars[current - 1] = '2';
              arrChars[current - 2] = '%';
              current = current - 3;
          }
          else
          {
              arrChars[current] = value.charAt(i);
              current--;
          }
      }
      
      value = arrChars.toString();
  }

• 将N*N矩阵旋转90度
  思路：我们可以拿3*3矩阵做例子，在旋转完毕后，前后矩阵元素的关系如下：
  　　a[0][0]=>a[0][2]
  　　a[0][1]=>a[1][2]
  　　a[0][2]=>a[2][2]
  　　a[1][0]=>a[0][1]
  　　a[1][1]=>a[1][1]
  　　a[1][2]=>a[2][1]
  　　a[2][0]=>a[0][0]
  　　a[2][1]=>a[1][0]
  　　a[2][2]=>a[2][0]
  我们可以得到以下转换规则：a[x][y]=>a[y][n-x]。
  

  public static void rotate(int[][] matrix)
  {
      if (matrix == null) return;
      int length = matrix.length - 1;
      for (int i = 0; i < length/2; i++)
      {
          for (int j = 0; j < length; j++)
          {
              int temp = matrix[i][j];
              matrix[i][j] = matrix[j][length - i];
              matrix[j][length - i] = matrix[length - i][length - j];
              matrix[length - i][length - j] = matrix[length - j][i];
              matrix[length - j][i] = temp;
          }
      }
  }

• 对N*M 矩阵进行处理，如果某个元素为0，则将该元素对应的行与列都设置为0
  思路：不能直接对矩阵进行设置0的处理，因为再设置0后，还需要进行遍历，这样可能导致最终矩阵所有元素都为0，需要先将为0的元素进行保存，然后再处理。
  

  public static void setZeros(int[][] matrix)
  {
      if (matrix == null) return;
      int[] arrX = new int[matrix.length];
      int[] arrY = new int[matrix[0].length];
      for(int i = 0; i < matrix.length; i++)
      {
          for (int j = 0; j < matrix[i].length; j++)
          {
              if (matrix[i][j] == 0)
              {
                  arrX[i] = 1;
                  arrY[j] = 1;
              }
          }
      }
      for (int i = 0; i < matrix.length; i++)
      {
          for (int j = 0; j < matrix[i].length; j++)
          {
              if (arrX[i] == 1 || arrY[j] == 1)
              {
                  matrix[i][j] = 0;
              }
          }
      }
  }

• 判断一个字符串是否是另一个字符串经过翻转后得到的结果，例如cdab就是abcd进行翻转后的结果
  思路：将一个字符串拼接到自己后面，然后判断另一个字符串是否是新字符串的子串。
  

  public static boolean isRotation(String value1, String value2)
  {
      if (value1 == null || value2 == null || value1.length() != value2.length())
          return false;
      String newValue = value1 + value1;
      return newValue.contains(value2);
  }

  
  
  最后，欢迎大家提出更多和字符串相关的面试题目，我们可以一起讨论。