1

好的，所以我的一个朋友让我帮助他使用一种无​​需使用 String.Reverse 即可重用的字符串反转方法（这是他的家庭作业）。现在，我做到了，下面是代码。有用。其实很精彩。显然，通过查看它，您可以看到字符串越大，工作所需的时间就越长。但是，我的问题是它为什么有效？编程需要大量的试验和错误，我的伪编码比实际的编码更多，而且它很有效。

有人可以向我解释一下 reverse = ch + reverse; 正在工作中？我不明白是什么让它倒转：/

class Program
{

    static void Reverse(string x)
    {

        string text = x;
        string reverse = string.Empty;
        foreach (char ch in text)
        {

            reverse = ch + reverse;
            // this shows the building of the new string. 
            // Console.WriteLine(reverse);
        }

        Console.WriteLine(reverse);        

    }
    static void Main(string[] args)
    {

        string comingin;
        Console.WriteLine("Write something");
        comingin = Console.ReadLine();
       Reverse(comingin);

        // pause
        Console.ReadLine();
    }



}
4

5 回答 5

2

如果传递的字符串是“hello”，则循环将执行以下操作：

reverse='h' +string.Empty

reverse='e' +'h'

reverse=“l”+“嗯”

直到等于

奥莱

于 2013-06-06T12:43:21.797 回答
2

如果您的字符串是My String，则：

Pass 1, reverse = 'M'
Pass 2, reverse = 'yM'
Pass 3, reverse = ' yM'

您正在接受每个字符并说“那个字符并在它之后加上我之前拥有的东西”。

于 2013-06-06T12:43:26.217 回答
2

我想你的问题已经回答了。我的回答超出了直接的问题，更多的是练习的精神。我记得几十年前在大学里有过这项任务，当时内存和大型机（哎呀！）处理时间非常宝贵。我们的任务是反转一个数组或字符串，它是一个字符数组，而不创建第二个数组或字符串。练习的精神是教一个人注意可用的资源。

在 .NET 中，字符串是不可变对象，因此我必须使用第二个字符串。我又写了 3 个示例来演示不同的技术，它们可能比您的方法更快，但不应该用于替换内置的 .NET Replace 方法。我偏向于最后一个。

    // StringBuilder inserting at 0 index
    public static string Reverse2(string inputString)
    {
        var result = new StringBuilder();
        foreach (char ch in inputString)
        {
            result.Insert(0, ch);
        }
        return result.ToString();
    }

    // Process inputString backwards and append with StringBuilder
    public static string Reverse3(string inputString)
    {
        var result = new StringBuilder();
        for (int i = inputString.Length - 1; i >= 0; i--)
        {
            result.Append(inputString[i]);
        }
        return result.ToString();
    }

    // Convert string to array and swap pertinent items
    public static string Reverse4(string inputString)
    {
        var chars = inputString.ToCharArray();
        for (int i = 0; i < (chars.Length/2); i++)
        {
            var temp = chars[i];
            chars[i] = chars[chars.Length - 1 - i];
            chars[chars.Length - 1 - i] = temp;
        }
        return new string(chars);
    }
于 2013-06-06T13:23:38.927 回答
1

请想象您的输入字符串是“abc”。之后，您可以看到字母被一个接一个地添加到新字符串的开头：

  1. 反向 = "", ch='a' ==> 反向 (ch+reverse) = "a"
  2. 反向=“a”，ch='b'==>反向（ch+reverse）=b+a=“ba”
  3. 反向= "ba", ch='c' ==> 反向 (ch+reverse) = c+ba = "cba"
于 2013-06-06T12:45:51.807 回答
1

为了测试 Romoku 的使用建议，StringBuilder我生成了以下代码。

   public static void Reverse(string x)
        {
            string text = x;
            string reverse = string.Empty;
            foreach (char ch in text)
            {
                reverse = ch + reverse;
            }
            Console.WriteLine(reverse);
        }

        public static void ReverseFast(string x)
        {
            string text = x;
            StringBuilder reverse = new StringBuilder();
            for (int i = text.Length - 1; i >= 0; i--)
            {
                reverse.Append(text[i]);
            }             
            Console.WriteLine(reverse);
        }

        public static void Main(string[] args)
        {
            int abcx = 100; // amount of abc's
            string abc = ""; 
            for (int i = 0; i < abcx; i++)
                abc += "abcdefghijklmnopqrstuvwxyz";
            var x = new System.Diagnostics.Stopwatch();
            x.Start();
            Reverse(abc);
            x.Stop();
            string ReverseMethod = "Reverse Method: " + x.ElapsedMilliseconds.ToString();
            x.Restart();
            ReverseFast(abc);
            x.Stop();
            Console.Clear();
            Console.WriteLine("Method | Milliseconds");
            Console.WriteLine(ReverseMethod);
            Console.WriteLine("ReverseFast Method: " + x.ElapsedMilliseconds.ToString());
            System.Console.Read();
        }

在我的计算机上，这些是我获得每数量字母的速度。

100 ABC(s) Reverse ~5-10ms FastReverse ~5-15ms

1000 ABC(s) Reverse ~120ms FastReverse ~20ms

10000 ABC(s) 反向~16,852 毫秒！！！ 快速反向 ~262ms

这些时间结果会因计算机的不同而有很大差异，但可以肯定的是，如果您正在处理超过 100k 个字符，您会因为不使用而发疯StringBuilder！另一方面，如果您处理的字符数少于 2000 个，那么来自 的开销StringBuilder肯定会赶上它的性能提升。

于 2013-06-06T13:33:44.440 回答