Question

好的，所以我的一个朋友让我用一个字符串反向方法帮助他，可以在不使用String.Reverse的情况下重复使用（这是他的家庭作业）。现在，我做了，下面是代码。有用。实际上非常棒。显然，通过查看它，您可以看到字符串越大，工作所需的时间就越长。但是，我的问题是为什么它有效？编程是一个很多的试验和错误，我比实际编码更多的伪编码，它工作大声笑。

有人可以向我解释究竟是反向= ch +反向;工作中？我不明白是什么让它逆转：/

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();
    }



}

Answer 1

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

reverse ='h'+ string.Empty

reverse ='e'+'h'

reverse ='l'+'eh'

直到它等于

2009东海生日贺

Answer 2

如果你的字符串是My String，那么：

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

你正在拍摄每一个字母并说“在之后之前我所拥有的那个角色和特色”。

Answer 3

请想象你入口字符串是“abc”。之后，您可以看到逐个字母并添加到新字符串的开头：

reverse =“”，ch ='a'==＆gt;反向（ch +反向）=“a”
reverse =“a”，ch ='b'==＆gt;反向（ch +反向）= b + a =“ba”
reverse =“ba”，ch ='c'==＆gt;反向（ch +反向）= c + ba =“cba”

Answer 4

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

在.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);
    }

Answer 5

为了测试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）反向~5-10ms FastReverse~5-15ms

1000 ABC（s）反向~120ms FastReverse~20ms

10000 ABC（s）反向 ~16,852ms !!! FastReverse~262ms

这些时间结果会因计算机的不同而有很大差异，但有一件事是肯定的，如果你处理超过10万个字符，你就不会使用StringBuilder而疯狂！另一方面，如果处理的字符少于2000个字符，StringBuilder的开销似乎肯定会赶上性能提升。

在不使用Reverse的情况下反转String。它有效，但为什么呢？

5 个答案: