【问题标题】:Reversing a string without creating extra memory在不创建额外内存的情况下反转字符串
【发布时间】:2021-04-02 19:13:21
【问题描述】:

我有一个大约 1mb 大小的字符串。要求是在不分配另一个大小为 1 MB 的临时字符串的情况下反转字符串。我尝试了以下代码

string name = "abcde";

string target = "";
for(int i = name.Length - 1; i >=0; i--)
{
    target += name[i];
    name = name.Remove(i);                
    int n = name.Length;
}

但我的朋友说如果我们使用函数name.Remove(i),它会返回一个新字符串,但不能保证旧字符串会从内存中删除,因此不能保证大小会减小。是真的吗?如果是这样,是否有任何其他选项可用于在不分配额外内存的情况下反转字符串?

【问题讨论】:

  • 您可以尝试以相反的顺序将其写入文件,然后再将其读回:-)
  • @paxdiablo:好主意,原始字符串会怎样?我们能保证删除它吗
  • 为什么在不允许额外内存的情况下反转标准?垃圾收集器非常擅长它的工作。
  • 每次执行 name = name.Remove(i) 时,都会创建另一个字符串减去字符(根据我对不可变对象的理解)。因此,如果这是真的,那么您将创建大量字符串来实现这一目标。
  • 请注意,简单地反转数组并不是有效的解决方案,因为这不会考虑可能导致无效甚至损坏的字符串的代理和 unicode 标记代码点

标签: c#


【解决方案1】:

您的字符串“abcde”是内存中的常量。你不能改变它,因为它是不可变的。你想要的是创建一个新的字符串,为此你需要新的内存。

【讨论】:

    【解决方案2】:

    使用StringBuilder,您可以使用字符数组进行操作,但不能使用string,因为它是不可变的

    【讨论】:

      【解决方案3】:

      字符串是不可变的,如果不分配新内存就无法反转它

      String from MSDN

      字符串是不可变的——字符串对象的内容不能 创建对象后更改,尽管语法使其 看起来好像你能做到。

      从同一个链接看这个例子:

      string b = "h";
      b += "ello";
      

      和解释。

      当您编写此代码时,编译器实际上会创建一个新字符串 对象来保存新的字符序列,并且该新对象是 分配给 b.然后字符串“h”就可以进行垃圾回收了。

      【讨论】:

      • 是否可以用比原字符串更少的内存来反转它?
      • @Jeeva,当您将字符串反转时,您之前的字符串将有资格进行垃圾回收,您不必担心。
      【解决方案4】:

      字符串是不可变的。当您声明它时,您无法更改它。所以无论你尝试什么,都会创建和使用新的内存。

      string name = "aaaaa":
      name = name.Remove(0); // this is allocating new memory.
      

      【讨论】:

        【解决方案5】:
        class Program
        {
            static void Main(string[] args)
            {
                //Note how I don't bother to use a variable?
                //This is a nasty hack that knows the compiler will intern the value.
                //One of the many downsides of hacking the BCL.
                while (string.IsNullOrWhiteSpace(Console.ReadLine()))
                {
                    Console.WriteLine("he\0llo");  
                    "he\0llo".ReverseInPlace();
                }
            }
        }
        
        public static class Helper
        {
            //Does not support multi-char values.
            public static unsafe void ReverseInPlace(this string str)
            {
                fixed (char* pfixed = str)
                    for (int i = 0, ii = str.Length - 1; i < str.Length / 2; i++, ii--)
                    {
                        var p1 = (char*)pfixed + i;
                        var p2 = (char*)pfixed + ii;
                        var temp = *p1;
                        *p1 = *p2;
                        *p2 = temp;
                    }
            }
        }
        

        如果你使用这个,你很可能会死……或者什么。哎呀,我什至不知道如何编写不安全的代码。

        【讨论】:

          【解决方案6】:

          如果您对原始数据有一定的控制权,您应该能够做到这一点。例如。如果您可以要求 char[] 而无需创建 string,则可以将其原地反转。

          例如,在 您的 示例中,您可以使用 var name = new char[] { 'a', 'b', 'c', 'd', 'e'} 而不是字符串,然后将其反转。

          (显然您不能对 1MB 的字符串执行此操作,但是无论您从哪里获取字符串,如果您最初可以将其加载为 char[] 而不是...)

          如果您只能拥有一个string,那您就不走运了。它们是不可变的 - 您只能通过以某种方式复制字符串来修改它。

          【讨论】:

            【解决方案7】:

            StringBuilder 是可变的,在这种情况下应该给你最好的效率

            string inpuStr = "The quick brown fox jumped over the lazy dog...blah blah blah up to 1MB";
            StringBuilder builder = new StringBuilder();
                        for (int i = inpuStr.Length - 1; i >= 0; i--)
                        {
                            builder.Append(inpuStr[i]); 
                        }
                       return builder.ToString();
            

            【讨论】:

              【解决方案8】:
              you can try with linq to reverse
              
                  string original = "abcde";
                  string reverseValue = new string(original.Reverse().ToArray());
              
              you can try also with 
              
              string result= new string(original.Select((c, index) => new { c, index })
                                                       .OrderByDescending(x => x.index)
                                                       .ToArray());
              

              【讨论】:

              • 怎么不创造新的记忆?
              • @MBen 如果您初始化一个局部变量,您会将值存储在堆栈中
              【解决方案9】:

              编辑:完全失去了情节,最近使用 C++ 太多了,我忘记了 C# 字符串是不可变的。

              简而言之,您必须分配新内存来更改 C# 中的字符串。您可以通过执行以下操作以最直接的方式执行此操作:

              string ReverseString(string value)
              {
                  if (!string.IsNullOrEmpty(value))
                  {
                      char[] newBuffer = new char[value.Length];
                      for(int i = 0; i < value.Length; i++)
                          newBuffer[newBuffer.Length - i - 1] = value[i];
                      value = new string(newBuffer);
                  }
                  return value;
              }
              

              【讨论】:

              • 你确定吗?字符串不是不可变的吗?
              • 是的,不知道我到底在想什么。最近似乎使用了太多 C++。
              • 字符串是不可变的,name[0] = 'e' 不能编译。
              • 大声笑,当我的答案中有不正确的信息时,我理解了最初的几票否决,但现在考虑到信息是正确的,这变得有点愚蠢,这里有一个工作示例。
              【解决方案10】:

              实际上,如果不分配与要反转的字符串所占用的内存量相同的内存量,就没有正确的方法来反转字符串。 (理论上它可以在内存中反转一个字符串,但这是非常不推荐的,我什至不会进入那个区域)。现在至于反转字符串本身。我正在做一个名为 StringExtensions 的小项目,在这个项目中,我尝试解决使用字符串时可能出现的所有问题。最大的问题之一是使用在整个框架中广泛使用的 UTF-16 编码。我的反转字符串的实现如下所示:

                  static IEnumerable<Tuple<int, int>> GetTextElementSegments(string value)
                  {
                      int[] elementOffsets = StringInfo.ParseCombiningCharacters(value);
              
                      int lastOffset = -1;
                      foreach (int offset in elementOffsets)
                      {
                          if (lastOffset != -1)
                          {
                              int elementLength = offset - lastOffset;
                              Tuple<int, int> segment = new Tuple<int,int>(lastOffset, elementLength);
                              yield return segment;
                          }
              
                          lastOffset = offset;
                      }
              
                      if (lastOffset != -1)
                      {
                          int lastSegmentLength = value.Length - lastOffset;
              
                          Tuple<int, int> segment = new Tuple<int, int>(lastOffset, lastSegmentLength);
                          yield return segment;
                      }
                  }
              
                  static void Main(string[] args)
                  {
                      string input = "t\u0301e\u0302s\u0303t\u0304";
                      StringBuilder resultBuilder = new StringBuilder(input.Length);
              
                      var segments = GetTextElementSegments(input);
              
                      foreach (var segment in segments.Reverse())
                      {
                          resultBuilder.Append(input, segment.Item1, segment.Item2);
                      }
              
                      Debug.Assert(resultBuilder.ToString() == "t\u0304s\u0303e\u0302t\u0301s");
                  }
              

              请注意,这会处理代理对、unicode 标记代码点,并且只分配与输入字符串本身占用的内存量相似的内存。

              【讨论】:

                【解决方案11】:

                如果你真的不想额外分配,你需要fix字符串并使用unsafe指针代码。或者,也许,使用反射获取对内部 char[] 的引用。

                你真的不想这样做。真的。我的意思是,真的。请不要这样做,除非作为学习练习。如果人们在生产中发现这样的代码,他们很可能会带着武器来找你。

                我不会尝试编写这样的代码(因为我知道我会弄错)。但这里有一些链接可以帮助您入门:

                【讨论】:

                  【解决方案12】:

                  我刚刚为此做了一个 Java 解决方案,使用字符串的 toCharArray() 函数和 XOR 操作来交换字符:

                  public static String reverseString(String str) {
                      return reverseStringXor(str.toCharArray(), 0, str.length() - 1);
                  }
                  
                  private static String reverseStringXor(char[] str, int start, int end) {
                      while (start < end) {
                          str[start] ^= str[end];
                          str[end] ^= str[start];
                          str[start] ^= str[end];
                          start++;
                          end--;
                      }
                      return String.valueOf(str);
                  }
                  

                  【讨论】:

                    【解决方案13】:

                    这应该会有所帮助

                    string reverse = new string("ABCDEFGHI".ToCharArray().Reverse().ToArray());
                    

                    【讨论】:

                    • 这仍然会使用额外的内存。
                    【解决方案14】:

                    这是你的答案之一。

                     for (int i = textBox1.TextLength - 1; i >= 0; i--)
                     {
                        textBox1.Text += textBox1.Text[i];
                     }
                     textBox1.Text = textBox1.Text.Remove(0, textBox1.Text.Length / 2);
                    

                    【讨论】:

                      猜你喜欢
                      • 1970-01-01
                      • 2018-02-09
                      • 1970-01-01
                      • 2017-06-15
                      • 2021-12-09
                      • 2017-02-12
                      • 1970-01-01
                      • 1970-01-01
                      • 2019-02-20
                      相关资源
                      最近更新 更多