Java 编写反向字符串O（N）时间复杂度和O（N）空间复杂度的程序

我被要求解决以下小于N^2时间复杂度和O（N）空间复杂度的问题：

为以下大小写反向字符串编写程序：

输入：-“你好，世界” 输出：-“olleH dlroW”

我已经尝试了很多，但是无论我尝试了什么，我都不能得出一个低于N^2的时间复杂度，我的代码可以在下面看到，你有什么建议我怎样才能得出一个线性时间的解决方案

注意：不允许使用内置方法

publicstaticstringreverser（stringstr）{
if（str==null | | str.isEmpty（））{
抛出新的IllegalArgumentException（）；
}
如果（str.length（）<2）{
返回str；
}
字符串[]strArr=str.split（“”）；
StringBuffer newHolder=新StringBuffer（）；
对于（int i=0；i

以下算法使用O（n）空间，并将输入字符串精确迭代两次（我认为这满足时间复杂性）。输入字符串的一次迭代是查找空格，另一次迭代是写出相反的单词

算法是这样的：

• 找到第一个空间（跟踪空间的位置）
• 以相反的顺序写第一个单词（记录下一个单词的起始位置）
• 重复，直到字符串结束

  public class ReverseEachWord {
  
  public static void main(String[] args) {
      String input = "Hello World";
      System.out.println(reverseEachWord(input));
  }
  
  public static String reverseEachWord(String input) {
  
      int len = input.length();
  
      char[] out = new char[len]; // O(n) space
      char[] in = input.toCharArray();
  
      int spacePos = 0;
      int activePos = 0;
  
      while (activePos < len) {
          spacePos = activePos+1;
          int spaceFound = -1;
          int offset = 0;
          while (spacePos < len) {
              if (in[spacePos] == ' ') {
                  out[spacePos] = ' ';
                  spaceFound = 0;
                  break;
              }
              spacePos++;
          }
          if (spaceFound < 0) {
              spacePos += spaceFound;
              offset = 1;
          }
  
          for (int i=0; i<(spacePos-activePos+offset); i++) {
              out[spacePos - i -1 - spaceFound] = in[i+activePos];
          }
          activePos = spacePos+1;
  
      }
  
      return Arrays.toString(out);
  }
  

  public类ReverseEachWord{
  公共静态void main（字符串[]args）{
  字符串输入=“你好世界”；
  System.out.println（reverseEachWord（输入））；
  }
  公共静态字符串反向eachword（字符串输入）{
  int len=input.length（）；
  char[]out=new char[len]；//O（n）空间
  char[]in=input.toCharArray（）；
  int spacePos=0；
  int-activePos=0；
  while（activePosfor（int i=0；i看起来您想反转字符串中的单词，而不是整个字符串。现在：
  
  public static String reverseWords(String str)
  {
      char[] chars = str.toCharArray();
      int wstart=0;
      for (int pos=0;;pos++)
      {
          if (pos < chars.length && chars[pos]!=' ')
          {
              continue;
          }
          for (int wend=pos-1; wend>wstart; ++wstart,--wend)
          {
              char t=chars[wstart];
              chars[wstart]=chars[wend];
              chars[wend]=t;
          }
          if (pos>=chars.length)
          {
              break;
          }
          wstart=pos+1;
      }
      return String.valueOf(chars);
  }
  
  publicstaticstringreverseewords（stringstr）
  {
  char[]chars=str.toCharArray（）；
  int-wstart=0；
  对于（int pos=0；pos++）
  {
  如果（位置wstart；++wstart，--wend）
  {
  chart=chars[wstart]；
  chars[wstart]=chars[wend]；
  chars[wend]=t；
  }
  如果（位置>=字符长度）
  {
  打破
  }
  wstart=pos+1；
  }
  返回字符串.valueOf（字符）；
  }
  
  这是你能找到的最快、最节省空间的版本。如果这是作业，你的教授会知道你没有写：）
  
  然而，你在问题中所写的满足要求——O（N）时间和O（N）空间——所以你可能想要交上这一个。祝贺你
  
  由于您似乎认为这需要O（N^2）个时间，因此时间是如何分解的：
  
  
  str.split:O（输出数组的大小+输出字符串的大小）=O（str.length（）），即O（N）
  迭代字数：O（字数）=O（N）
  创建和反转字串：每个字串为O（字号），总计为O（N）
  newHolder.append:O（创建的字符串的总大小）=O（str.length（））=O（N）
  toString（）：O（输出大小）=O（N）
  
  因此，5*O（N）=O（N）--您可以开始了。
  您正在使用
  split（）
  ，这会增加解决方案的O（N）时间复杂性。此外，您还说内置方法不能使用
  
  这里有一个伪代码供您尝试。据我所知，它的时间复杂度为O（N），空间复杂度仅为O（N）
  
  i = 0, j = 0
  for i = 0 to str.length:
      if str[i] == ' ':
          for k=i-1 to j:    // reverse looping
              print str[k]
          j = i + 1
  // printing the last word
  for k=i to j:
      print(s[k])
  
  这是我对复杂性的直觉。外循环给出O（N），内循环为每个单词一次，所以它再次给出另一个O（N），这意味着总的复杂性是O（N）。至于空间，如果将字符存储在另一个数组中而不是打印，则需要一个大小为N的数组，其中N是源字符串的大小。因此，空间复杂度也是O（N）
  
  
  下面是伪代码的java实现：
  
  public static String reverseIt(String str) {
  
      char[] source = str.toCharArray();
      char[] newArray = new char[source.length];
  
      int i = 0, j = 0, idx = 0;
  
      for(i = 0; i < source.length; i++) {
          if(source[i] == ' ') {
              for(int k = i-1; k >= j; k--, idx++) {
                  newArray[idx] = source[k];
              }
              j = i + 1;
              newArray[idx++] = ' ';
          }
      }
      for(int k = i-1; k >= j; k--, idx++) {
          newArray[idx] = source[k];
      }
  
      return new String(newArray);
  }
  
  publicstaticstringreverseit（stringstr）{
  char[]source=str.toCharArray（）；
  char[]newArray=newchar[source.length]；
  int i=0，j=0，idx=0；
  对于（i=0；i=j；k--，idx++）{
  newArray[idx]=源[k]；
  }
  j=i+1；
  新数组[idx++]=''；
  }
  }
  对于（intk=i-1；k>=j；k--，idx++）{
  newArray[idx]=源[k]；
  }
  返回新字符串（newArray）；
  }
  公共字符串反转（字符串str）
  {
  char[]chars=str.toCharArray（）；
  int end=chars.length-1，half_len=（int）Math.ceil（chars.length/2）；
  对于（int i=0；i
  返回新的StringBuilder（str）.reverse（）.toString（）；
  这是一个算法问题，因此不允许使用内置方法
  public static String reverseIt(String str) {
  
      char[] source = str.toCharArray();
      char[] newArray = new char[source.length];
  
      int i = 0, j = 0, idx = 0;
  
      for(i = 0; i < source.length; i++) {
          if(source[i] == ' ') {
              for(int k = i-1; k >= j; k--, idx++) {
                  newArray[idx] = source[k];
              }
              j = i + 1;
              newArray[idx++] = ' ';
          }
      }
      for(int k = i-1; k >= j; k--, idx++) {
          newArray[idx] = source[k];
      }
  
      return new String(newArray);
  }
  
  public String reverse(String str)
  {
  char [] chars= str.toCharArray();
  int end=chars.length-1, half_len = (int) Math.ceil(chars.length/2);
  
  for(int i=0;i<half_len;i++)
  {
      if(chars[i]==' ')
      {
          continue;
      }
      else
      {
          char t=chars[i];
          chars[i]=chars[end];
          chars[end]=t;
      }
      end--;
  }
  }