Cara terbaik untuk membalik string

Saya baru saja menulis fungsi string reverse di C # 2.0 (yaitu LINQ tidak tersedia) dan muncul dengan ini:

public string Reverse(string text)
{
    char[] cArray = text.ToCharArray();
    string reverse = String.Empty;
    for (int i = cArray.Length - 1; i > -1; i--)
    {
        reverse += cArray[i];
    }
    return reverse;
}

Secara pribadi saya tidak tergila-gila dengan fungsi dan yakin bahwa ada cara yang lebih baik untuk melakukannya. Disana?

public static string Reverse( string s )
{
    char[] charArray = s.ToCharArray();
    Array.Reverse( charArray );
    return new string( charArray );
}

Di sini solusi yang membalikkan string "Les Mise\u0301rables"dengan benar "selbare\u0301siM seL". Ini harus memberikan seperti selbarésiM seL, bukan selbaŕesiM seL(perhatikan posisi aksen), seperti hasil sebagian besar implementasi berdasarkan unit kode ( Array.Reverse, dll) atau bahkan titik kode (membalikkan dengan perhatian khusus untuk pasangan pengganti).

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;

public static class Test
{
    private static IEnumerable<string> GraphemeClusters(this string s) {
        var enumerator = StringInfo.GetTextElementEnumerator(s);
        while(enumerator.MoveNext()) {
            yield return (string)enumerator.Current;
        }
    }
    private static string ReverseGraphemeClusters(this string s) {
        return string.Join("", s.GraphemeClusters().Reverse().ToArray());
    }

    public static void Main()
    {
        var s = "Les Mise\u0301rables";
        var r = s.ReverseGraphemeClusters();
        Console.WriteLine(r);
    }
}

(Dan contoh menjalankan langsung di sini: https://ideone.com/DqAeMJ )

Itu hanya menggunakan. NET API untuk iterasi cluster grapheme , yang telah ada sejak itu, tetapi sedikit "tersembunyi" dari pandangan, tampaknya.

Ini ternyata menjadi pertanyaan yang sangat rumit.

Saya akan merekomendasikan menggunakan Array. Membalik sebagian besar kasus karena dikodekan secara asli dan sangat mudah untuk mempertahankan dan memahami.

Tampaknya mengungguli StringBuilder dalam semua kasus yang saya uji.

public string Reverse(string text)
{
   if (text == null) return null;

   // this was posted by petebob as well 
   char[] array = text.ToCharArray();
   Array.Reverse(array);
   return new String(array);
}

Ada pendekatan kedua yang bisa lebih cepat untuk panjang string tertentu yang menggunakan Xor .

    public static string ReverseXor(string s)
    {
        if (s == null) return null;
        char[] charArray = s.ToCharArray();
        int len = s.Length - 1;

        for (int i = 0; i < len; i++, len--)
        {
            charArray[i] ^= charArray[len];
            charArray[len] ^= charArray[i];
            charArray[i] ^= charArray[len];
        }

        return new string(charArray);
    }

Catatan Jika Anda ingin mendukung rangkaian karakter Unicode UTF16 baca ini . Dan gunakan implementasi di sana sebagai gantinya. Ini dapat dioptimalkan lebih lanjut dengan menggunakan salah satu dari algoritma di atas dan berjalan melalui string untuk membersihkannya setelah karakter dibalik.

Berikut ini adalah perbandingan kinerja antara metode StringBuilder, Array.Reverse dan Xor.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace ConsoleApplication4
{
    class Program
    {
        delegate string StringDelegate(string s);

        static void Benchmark(string description, StringDelegate d, int times, string text)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            for (int j = 0; j < times; j++)
            {
                d(text);
            }
            sw.Stop();
            Console.WriteLine("{0} Ticks {1} : called {2} times.", sw.ElapsedTicks, description, times);
        }

        public static string ReverseXor(string s)
        {
            char[] charArray = s.ToCharArray();
            int len = s.Length - 1;

            for (int i = 0; i < len; i++, len--)
            {
                charArray[i] ^= charArray[len];
                charArray[len] ^= charArray[i];
                charArray[i] ^= charArray[len];
            }

            return new string(charArray);
        }

        public static string ReverseSB(string text)
        {
            StringBuilder builder = new StringBuilder(text.Length);
            for (int i = text.Length - 1; i >= 0; i--)
            {
                builder.Append(text[i]);
            }
            return builder.ToString();
        }

        public static string ReverseArray(string text)
        {
            char[] array = text.ToCharArray();
            Array.Reverse(array);
            return (new string(array));
        }

        public static string StringOfLength(int length)
        {
            Random random = new Random();
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < length; i++)
            {
                sb.Append(Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65))));
            }
            return sb.ToString();
        }

        static void Main(string[] args)
        {

            int[] lengths = new int[] {1,10,15,25,50,75,100,1000,100000};

            foreach (int l in lengths)
            {
                int iterations = 10000;
                string text = StringOfLength(l);
                Benchmark(String.Format("String Builder (Length: {0})", l), ReverseSB, iterations, text);
                Benchmark(String.Format("Array.Reverse (Length: {0})", l), ReverseArray, iterations, text);
                Benchmark(String.Format("Xor (Length: {0})", l), ReverseXor, iterations, text);

                Console.WriteLine();    
            }

            Console.Read();
        }
    }
}

Inilah hasilnya:

26251 Ticks String Builder (Length: 1) : called 10000 times.
33373 Ticks Array.Reverse (Length: 1) : called 10000 times.
20162 Ticks Xor (Length: 1) : called 10000 times.

51321 Ticks String Builder (Length: 10) : called 10000 times.
37105 Ticks Array.Reverse (Length: 10) : called 10000 times.
23974 Ticks Xor (Length: 10) : called 10000 times.

66570 Ticks String Builder (Length: 15) : called 10000 times.
26027 Ticks Array.Reverse (Length: 15) : called 10000 times.
24017 Ticks Xor (Length: 15) : called 10000 times.

101609 Ticks String Builder (Length: 25) : called 10000 times.
28472 Ticks Array.Reverse (Length: 25) : called 10000 times.
35355 Ticks Xor (Length: 25) : called 10000 times.

161601 Ticks String Builder (Length: 50) : called 10000 times.
35839 Ticks Array.Reverse (Length: 50) : called 10000 times.
51185 Ticks Xor (Length: 50) : called 10000 times.

230898 Ticks String Builder (Length: 75) : called 10000 times.
40628 Ticks Array.Reverse (Length: 75) : called 10000 times.
78906 Ticks Xor (Length: 75) : called 10000 times.

312017 Ticks String Builder (Length: 100) : called 10000 times.
52225 Ticks Array.Reverse (Length: 100) : called 10000 times.
110195 Ticks Xor (Length: 100) : called 10000 times.

2970691 Ticks String Builder (Length: 1000) : called 10000 times.
292094 Ticks Array.Reverse (Length: 1000) : called 10000 times.
846585 Ticks Xor (Length: 1000) : called 10000 times.

305564115 Ticks String Builder (Length: 100000) : called 10000 times.
74884495 Ticks Array.Reverse (Length: 100000) : called 10000 times.
125409674 Ticks Xor (Length: 100000) : called 10000 times.

Tampaknya Xor bisa lebih cepat untuk string pendek.

Jika Anda dapat menggunakan LINQ (.NET Framework 3.5+) daripada mengikuti satu liner akan memberi Anda kode pendek. Jangan lupa menambahkan using System.Linq;untuk memiliki akses ke Enumerable.Reverse:

public string ReverseString(string srtVarable)
{
    return new string(srtVarable.Reverse().ToArray());
}

Catatan:

• bukan versi tercepat - menurut Martin Niederl 5.7 kali lebih lambat daripada pilihan tercepat di sini.
• kode ini karena banyak opsi lain sama sekali mengabaikan segala macam kombinasi multi-karakter, jadi batasi penggunaan untuk tugas dan string pekerjaan rumah yang tidak mengandung karakter tersebut. Lihat jawaban lain dalam pertanyaan ini untuk implementasi yang benar menangani kombinasi tersebut.

Jika string berisi data Unicode (karakter non-BMP), metode lain yang telah diposting akan merusaknya, karena Anda tidak dapat menukar urutan unit kode pengganti tinggi dan rendah saat membalikkan string. (Informasi lebih lanjut tentang ini dapat ditemukan di blog saya .)

Contoh kode berikut akan membalikkan string yang berisi karakter non-BMP dengan benar, mis., "\ U00010380 \ U00010381" (Huruf Ugaritik Alpa, Huruf Ugaritik Beta).

public static string Reverse(this string input)
{
    if (input == null)
        throw new ArgumentNullException("input");

    // allocate a buffer to hold the output
    char[] output = new char[input.Length];
    for (int outputIndex = 0, inputIndex = input.Length - 1; outputIndex < input.Length; outputIndex++, inputIndex--)
    {
        // check for surrogate pair
        if (input[inputIndex] >= 0xDC00 && input[inputIndex] <= 0xDFFF &&
            inputIndex > 0 && input[inputIndex - 1] >= 0xD800 && input[inputIndex - 1] <= 0xDBFF)
        {
            // preserve the order of the surrogate pair code units
            output[outputIndex + 1] = input[inputIndex];
            output[outputIndex] = input[inputIndex - 1];
            outputIndex++;
            inputIndex--;
        }
        else
        {
            output[outputIndex] = input[inputIndex];
        }
    }

    return new string(output);
}

Oke, demi "jangan ulangi diri Anda," saya menawarkan solusi berikut:

public string Reverse(string text)
{
   return Microsoft.VisualBasic.Strings.StrReverse(text);
}

Pemahaman saya adalah bahwa implementasi ini, tersedia secara default di VB.NET, dengan benar menangani karakter Unicode.

Greg Beech memposting unsafeopsi yang memang secepat mungkin (ini merupakan pembalikan di tempat); tetapi, seperti yang ditunjukkannya dalam jawabannya, itu adalah gagasan yang benar-benar membawa malapetaka .

Yang mengatakan, saya terkejut ada begitu banyak konsensus yang Array.Reversemerupakan metode tercepat. Masih ada unsafependekatan yang mengembalikan salinan string yang terbalik (tidak ada shenanigans pembalikan di tempat) secara signifikan lebih cepat daripada Array.Reversemetode untuk string kecil:

public static unsafe string Reverse(string text)
{
    int len = text.Length;

    // Why allocate a char[] array on the heap when you won't use it
    // outside of this method? Use the stack.
    char* reversed = stackalloc char[len];

    // Avoid bounds-checking performance penalties.
    fixed (char* str = text)
    {
        int i = 0;
        int j = i + len - 1;
        while (i < len)
        {
            reversed[i++] = str[j--];
        }
    }

    // Need to use this overload for the System.String constructor
    // as providing just the char* pointer could result in garbage
    // at the end of the string (no guarantee of null terminator).
    return new string(reversed, 0, len);
}

Berikut ini beberapa hasil benchmark .

Anda dapat melihat bahwa peningkatan kinerja menyusut dan kemudian menghilang terhadap Array.Reversemetode saat string semakin besar. Untuk string berukuran kecil hingga sedang, sulit untuk mengalahkan metode ini.

Jawaban yang mudah dan menyenangkan menggunakan Metode Ekstensi:

static class ExtentionMethodCollection
{
    public static string Inverse(this string @base)
    {
        return new string(@base.Reverse().ToArray());
    }
}

dan inilah hasilnya:

string Answer = "12345".Inverse(); // = "54321"

Jika Anda ingin memainkan permainan yang benar-benar berbahaya, maka ini adalah cara tercepat yang ada (sekitar empat kali lebih cepat daripada Array.Reversemetode ini). Ini adalah terbalik menggunakan pointer.

Perhatikan bahwa saya benar-benar tidak merekomendasikan ini untuk penggunaan apa pun, pernah ( lihat di sini untuk beberapa alasan mengapa Anda tidak harus menggunakan metode ini ), tetapi hanya menarik untuk melihat bahwa itu dapat dilakukan, dan string tidak benar-benar berubah. setelah Anda mengaktifkan kode yang tidak aman.

public static unsafe string Reverse(string text)
{
    if (string.IsNullOrEmpty(text))
    {
        return text;
    }

    fixed (char* pText = text)
    {
        char* pStart = pText;
        char* pEnd = pText + text.Length - 1;
        for (int i = text.Length / 2; i >= 0; i--)
        {
            char temp = *pStart;
            *pStart++ = *pEnd;
            *pEnd-- = temp;
        }

        return text;
    }
}

Lihatlah entri wikipedia di sini . Mereka menerapkan metode ekstensi String.Reverse. Ini memungkinkan Anda untuk menulis kode seperti ini:

string s = "olleh";
s.Reverse();

Mereka juga menggunakan kombinasi ToCharArray / Reverse yang disarankan oleh jawaban lain untuk pertanyaan ini. Kode sumber terlihat seperti ini:

public static string Reverse(this string input)
{
    char[] chars = input.ToCharArray();
    Array.Reverse(chars);
    return new String(chars);
}

Pertama, Anda tidak perlu memanggil ToCharArraystring yang sudah dapat diindeks sebagai array char, jadi ini akan menghemat alokasi.

Optimalisasi selanjutnya adalah menggunakan a StringBuilderuntuk mencegah alokasi yang tidak perlu (karena string tidak dapat diubah, menyatukannya membuat salinan string setiap kali). Untuk lebih mengoptimalkan ini, kami telah mengatur sebelumnya panjang StringBuildersehingga tidak perlu memperluas buffer-nya.

public string Reverse(string text)
{
    if (string.IsNullOrEmpty(text))
    {
        return text;
    }

    StringBuilder builder = new StringBuilder(text.Length);
    for (int i = text.Length - 1; i >= 0; i--)
    {
        builder.Append(text[i]);
    }

    return builder.ToString();
}

Edit: Data Kinerja

Saya menguji fungsi ini dan menggunakan fungsi Array.Reversedengan program sederhana berikut, di mana Reverse1satu fungsi dan Reverse2yang lainnya:

static void Main(string[] args)
{
    var text = "abcdefghijklmnopqrstuvwxyz";

    // pre-jit
    text = Reverse1(text); 
    text = Reverse2(text);

    // test
    var timer1 = Stopwatch.StartNew();
    for (var i = 0; i < 10000000; i++)
    {
        text = Reverse1(text);
    }

    timer1.Stop();
    Console.WriteLine("First: {0}", timer1.ElapsedMilliseconds);

    var timer2 = Stopwatch.StartNew();
    for (var i = 0; i < 10000000; i++)
    {
        text = Reverse2(text);
    }

    timer2.Stop();
    Console.WriteLine("Second: {0}", timer2.ElapsedMilliseconds);

    Console.ReadLine();
}

Ternyata untuk string pendek Array.Reversemetode ini sekitar dua kali lebih cepat dari yang di atas, dan untuk string yang lebih panjang perbedaannya bahkan lebih jelas. Jadi mengingat bahwa Array.Reversemetode ini lebih sederhana dan lebih cepat, saya sarankan Anda menggunakannya daripada yang ini. Saya meninggalkan yang ini di sini hanya untuk menunjukkan bahwa itu bukan cara yang harus Anda lakukan (sangat mengejutkan saya!)

Coba gunakan Array. Balikkan

public string Reverse(string str)
{
    char[] array = str.ToCharArray();
    Array.Reverse(array);
    return new string(array);
}

public static string Reverse(string input)
{
    return string.Concat(Enumerable.Reverse(input));
}

Tentu saja Anda dapat memperluas kelas string dengan metode Reverse

public static class StringExtensions
{
    public static string Reverse(this string input)
    {
        return string.Concat(Enumerable.Reverse(input));
    }
}

"Terbaik" dapat bergantung pada banyak hal, tetapi berikut beberapa alternatif pendek yang dipesan dari cepat ke lambat:

string s = "z̽a̎l͘g̈o̓😀😆", pattern = @"(?s).(?<=(?:.(?=.*$(?<=((\P{M}\p{C}?\p{M}*)\1?))))*)";

string s1 = string.Concat(s.Reverse());                          // "☐😀☐̓ög͘l̎a̽z"  👎

string s2 = Microsoft.VisualBasic.Strings.StrReverse(s);         // "😆😀o̓g̈l͘a̎̽z"  👌

string s3 = string.Concat(StringInfo.ParseCombiningCharacters(s).Reverse()
    .Select(i => StringInfo.GetNextTextElement(s, i)));          // "😆😀o̓g̈l͘a̎z̽"  👍

string s4 = Regex.Replace(s, pattern, "$2").Remove(s.Length);    // "😆😀o̓g̈l͘a̎z̽"  👍

Dimulai dengan .NET Core 2.1 ada cara baru untuk membalikkan string menggunakan string.Create metode ini.

Perhatikan bahwa solusi ini tidak menangani Unicode yang menggabungkan karakter dll dengan benar, karena "Les Mise \ u0301rables" akan dikonversi menjadi "selbarésiM seL". The jawaban yang lain untuk solusi yang lebih baik.

public static string Reverse(string input)
{
    return string.Create<string>(input.Length, input, (chars, state) =>
    {
        state.AsSpan().CopyTo(chars);
        chars.Reverse();
    });
}

Ini pada dasarnya menyalin karakter inputke string baru dan membalikkan string baru di tempat.

Kenapa string.Createbermanfaat?

Ketika kami membuat string dari array yang ada, array internal baru dialokasikan dan nilai-nilai disalin. Kalau tidak, akan mungkin untuk memutasikan string setelah pembuatannya (dalam lingkungan yang aman). Yaitu, dalam cuplikan berikut ini, kami harus mengalokasikan array dengan panjang 10 dua kali, satu sebagai buffer dan satu sebagai array internal string.

var chars = new char[10];
// set array values
var str = new string(chars);

string.Createdasarnya memungkinkan kita untuk memanipulasi array internal selama waktu pembuatan string. Ini, kita tidak perlu buffer lagi dan karena itu dapat menghindari mengalokasikan satu array char.

Steve Gordon telah menulisnya secara lebih rinci di sini . Ada juga artikel tentang MSDN .

Cara menggunakan string.Create?

public static string Create<TState>(int length, TState state, SpanAction<char, TState> action);

Metode ini mengambil tiga parameter:

1. Panjang string yang akan dibuat,
2. data yang ingin Anda gunakan untuk secara dinamis membuat string baru,
3. dan delegasi yang membuat string terakhir dari data, di mana parameter pertama menunjuk ke chararray internal dari string baru dan yang kedua adalah data (status) yang Anda berikan string.Create.

Di dalam delegasi kita dapat menentukan bagaimana string baru dibuat dari data. Dalam kasus kami, kami hanya menyalin karakter dari string input ke yang Spandigunakan oleh string baru. Kemudian kita membalikkannyaSpan dan karenanya seluruh string dibalik.

Tolak ukur

Untuk membandingkan cara saya yang diusulkan untuk membalik string dengan jawaban yang diterima, saya telah menulis dua tolok ukur menggunakan BenchmarkDotNet.

public class StringExtensions
{
    public static string ReverseWithArray(string input)
    {
        var charArray = input.ToCharArray();
        Array.Reverse(charArray);
        return new string(charArray);
    }

    public static string ReverseWithStringCreate(string input)
    {
        return string.Create(input.Length, input, (chars, state) =>
        {
            state.AsSpan().CopyTo(chars);
            chars.Reverse();
        });
    }
}

[MemoryDiagnoser]
public class StringReverseBenchmarks
{
    private string input;

    [Params(10, 100, 1000)]
    public int InputLength { get; set; }


    [GlobalSetup]
    public void SetInput()
    {
        // Creates a random string of the given length
        this.input = RandomStringGenerator.GetString(InputLength);
    }

    [Benchmark(Baseline = true)]
    public string WithReverseArray() => StringExtensions.ReverseWithArray(input);

    [Benchmark]
    public string WithStringCreate() => StringExtensions.ReverseWithStringCreate(input);
}

Inilah hasil di mesin saya:

| Method           | InputLength |         Mean |      Error |    StdDev |  Gen 0 | Allocated |
| ---------------- | ----------- | -----------: | ---------: | --------: | -----: | --------: |
| WithReverseArray | 10          |    45.464 ns |  0.4836 ns | 0.4524 ns | 0.0610 |      96 B |
| WithStringCreate | 10          |    39.749 ns |  0.3206 ns | 0.2842 ns | 0.0305 |      48 B |
|                  |             |              |            |           |        |           |
| WithReverseArray | 100         |   175.162 ns |  2.8766 ns | 2.2458 ns | 0.2897 |     456 B |
| WithStringCreate | 100         |   125.284 ns |  2.4657 ns | 2.0590 ns | 0.1473 |     232 B |
|                  |             |              |            |           |        |           |
| WithReverseArray | 1000        | 1,523.544 ns |  9.8808 ns | 8.7591 ns | 2.5768 |    4056 B |
| WithStringCreate | 1000        | 1,078.957 ns | 10.2948 ns | 9.6298 ns | 1.2894 |    2032 B |

Seperti yang Anda lihat, dengan ReverseWithStringCreatekami mengalokasikan hanya setengah dari memori yang digunakan oleh ReverseWithArraymetode ini.

Jangan repot-repot dengan fungsi, lakukan saja di tempat. Catatan: Baris kedua akan memunculkan eksepsi argumen di jendela Immediate dari beberapa versi VS.

string s = "Blah";
s = new string(s.ToCharArray().Reverse().ToArray()); 

Maaf untuk posting lama, tapi ini mungkin menarik

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        public static string ReverseUsingArrayClass(string text)
        {
            char[] chars = text.ToCharArray();
            Array.Reverse(chars);
            return new string(chars);
        }

        public static string ReverseUsingCharacterBuffer(string text)
        {
            char[] charArray = new char[text.Length];
            int inputStrLength = text.Length - 1;
            for (int idx = 0; idx <= inputStrLength; idx++) 
            {
                charArray[idx] = text[inputStrLength - idx];                
            }
            return new string(charArray);
        }

        public static string ReverseUsingStringBuilder(string text)
        {
            if (string.IsNullOrEmpty(text))
            {
                return text;
            }

            StringBuilder builder = new StringBuilder(text.Length);
            for (int i = text.Length - 1; i >= 0; i--)
            {
                builder.Append(text[i]);
            }

            return builder.ToString();
        }

        private static string ReverseUsingStack(string input)
        {
            Stack<char> resultStack = new Stack<char>();
            foreach (char c in input)
            {
                resultStack.Push(c);
            }

            StringBuilder sb = new StringBuilder();
            while (resultStack.Count > 0)
            {
                sb.Append(resultStack.Pop());
            }
            return sb.ToString();
        }

        public static string ReverseUsingXOR(string text)
        {
            char[] charArray = text.ToCharArray();
            int length = text.Length - 1;
            for (int i = 0; i < length; i++, length--)
            {
                charArray[i] ^= charArray[length];
                charArray[length] ^= charArray[i];
                charArray[i] ^= charArray[length];
            }

            return new string(charArray);
        }


        static void Main(string[] args)
        {
            string testString = string.Join(";", new string[] {
                new string('a', 100), 
                new string('b', 101), 
                new string('c', 102), 
                new string('d', 103),                                                                   
            });
            int cycleCount = 100000;

            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            for (int i = 0; i < cycleCount; i++) 
            {
                ReverseUsingCharacterBuffer(testString);
            }
            stopwatch.Stop();
            Console.WriteLine("ReverseUsingCharacterBuffer: " + stopwatch.ElapsedMilliseconds + "ms");

            stopwatch.Reset();
            stopwatch.Start();
            for (int i = 0; i < cycleCount; i++) 
            {
                ReverseUsingArrayClass(testString);
            }
            stopwatch.Stop();
            Console.WriteLine("ReverseUsingArrayClass: " + stopwatch.ElapsedMilliseconds + "ms");

            stopwatch.Reset();
            stopwatch.Start();
            for (int i = 0; i < cycleCount; i++) 
            {
                ReverseUsingStringBuilder(testString);
            }
            stopwatch.Stop();
            Console.WriteLine("ReverseUsingStringBuilder: " + stopwatch.ElapsedMilliseconds + "ms");

            stopwatch.Reset();
            stopwatch.Start();
            for (int i = 0; i < cycleCount; i++) 
            {
                ReverseUsingStack(testString);
            }
            stopwatch.Stop();
            Console.WriteLine("ReverseUsingStack: " + stopwatch.ElapsedMilliseconds + "ms");

            stopwatch.Reset();
            stopwatch.Start();
            for (int i = 0; i < cycleCount; i++) 
            {
                ReverseUsingXOR(testString);
            }
            stopwatch.Stop();
            Console.WriteLine("ReverseUsingXOR: " + stopwatch.ElapsedMilliseconds + "ms");            
        }
    }
}

Hasil:

• MembalikkanMenggunakanCharacterBuffer: 346ms
• ReverseUsingArrayClass: 87ms
• ReverseUsingStringBuilder: 824ms
• ReverseUsingStack: 2086ms
• ReverseUsingXOR: 319ms

public string Reverse(string input)
{
    char[] output = new char[input.Length];

    int forwards = 0;
    int backwards = input.Length - 1;

    do
    {
        output[forwards] = input[backwards];
        output[backwards] = input[forwards];
    }while(++forwards <= --backwards);

    return new String(output);
}

public string DotNetReverse(string input)
{
    char[] toReverse = input.ToCharArray();
    Array.Reverse(toReverse);
    return new String(toReverse);
}

public string NaiveReverse(string input)
{
    char[] outputArray = new char[input.Length];
    for (int i = 0; i < input.Length; i++)
    {
        outputArray[i] = input[input.Length - 1 - i];
    }

    return new String(outputArray);
}    

public string RecursiveReverse(string input)
{
    return RecursiveReverseHelper(input, 0, input.Length - 1);
}

public string RecursiveReverseHelper(string input, int startIndex , int endIndex)
{
    if (startIndex == endIndex)
    {
        return "" + input[startIndex];
    }

    if (endIndex - startIndex == 1)
    {
        return "" + input[endIndex] + input[startIndex];
    }

    return input[endIndex] + RecursiveReverseHelper(input, startIndex + 1, endIndex - 1) + input[startIndex];
}


void Main()
{
    int[] sizes = new int[] { 10, 100, 1000, 10000 };
    for(int sizeIndex = 0; sizeIndex < sizes.Length; sizeIndex++)
    {
        string holaMundo  = "";
        for(int i = 0; i < sizes[sizeIndex]; i+= 5)
        {   
            holaMundo += "ABCDE";
        }

        string.Format("\n**** For size: {0} ****\n", sizes[sizeIndex]).Dump();

        string odnuMaloh = DotNetReverse(holaMundo);

        var stopWatch = Stopwatch.StartNew();
        string result = NaiveReverse(holaMundo);
        ("Naive Ticks: " + stopWatch.ElapsedTicks).Dump();

        stopWatch.Restart();
        result = Reverse(holaMundo);
        ("Efficient linear Ticks: " + stopWatch.ElapsedTicks).Dump();

        stopWatch.Restart();
        result = RecursiveReverse(holaMundo);
        ("Recursive Ticks: " + stopWatch.ElapsedTicks).Dump();

        stopWatch.Restart();
        result = DotNetReverse(holaMundo);
        ("DotNet Reverse Ticks: " + stopWatch.ElapsedTicks).Dump();
    }
}

Keluaran

Untuk ukuran: 10

Naive Ticks: 1
Efficient linear Ticks: 0
Recursive Ticks: 2
DotNet Reverse Ticks: 1

Untuk ukuran: 100

Naive Ticks: 2
Efficient linear Ticks: 1
Recursive Ticks: 12
DotNet Reverse Ticks: 1

Untuk ukuran: 1000

Naive Ticks: 5
Efficient linear Ticks: 2
Recursive Ticks: 358
DotNet Reverse Ticks: 9

Untuk ukuran: 10000

Naive Ticks: 32
Efficient linear Ticks: 28
Recursive Ticks: 84808
DotNet Reverse Ticks: 33

Cara termudah:

string reversed = new string(text.Reverse().ToArray());

Solusi berbasis tumpukan.

    public static string Reverse(string text)
    {
        var stack = new Stack<char>(text);
        var array = new char[stack.Count];

        int i = 0;
        while (stack.Count != 0)
        {
            array[i++] = stack.Pop();
        }

        return new string(array);
    }

Atau

    public static string Reverse(string text)
    {
        var stack = new Stack<char>(text);
        return string.Join("", stack);
    }

Harus mengajukan contoh rekursif:

private static string Reverse(string str)
{
    if (str.IsNullOrEmpty(str) || str.Length == 1)
        return str;
    else
        return str[str.Length - 1] + Reverse(str.Substring(0, str.Length - 1));
}

Bagaimana tentang:

    private string Reverse(string stringToReverse)
    {
        char[] rev = stringToReverse.Reverse().ToArray();
        return new string(rev); 
    }

Saya telah membuat porta C # dari Microsoft.VisualBasic.Strings . Saya tidak yakin mengapa mereka menyimpan fungsi-fungsi yang berguna (dari VB) di luar System.String in Framework, tetapi masih di bawah Microsoft.VisualBasic. Skenario yang sama untuk fungsi keuangan (misalnya Microsoft.VisualBasic.Financial.Pmt()).

public static string StrReverse(this string expression)
{
    if ((expression == null))
        return "";

    int srcIndex;

    var length = expression.Length;
    if (length == 0)
        return "";

    //CONSIDER: Get System.String to add a surrogate aware Reverse method

    //Detect if there are any graphemes that need special handling
    for (srcIndex = 0; srcIndex <= length - 1; srcIndex++)
    {
        var ch = expression[srcIndex];
        var uc = char.GetUnicodeCategory(ch);
        if (uc == UnicodeCategory.Surrogate || uc == UnicodeCategory.NonSpacingMark || uc == UnicodeCategory.SpacingCombiningMark || uc == UnicodeCategory.EnclosingMark)
        {
            //Need to use special handling
            return InternalStrReverse(expression, srcIndex, length);
        }
    }

    var chars = expression.ToCharArray();
    Array.Reverse(chars);
    return new string(chars);
}

///<remarks>This routine handles reversing Strings containing graphemes
/// GRAPHEME: a text element that is displayed as a single character</remarks>
private static string InternalStrReverse(string expression, int srcIndex, int length)
{
    //This code can only be hit one time
    var sb = new StringBuilder(length) { Length = length };

    var textEnum = StringInfo.GetTextElementEnumerator(expression, srcIndex);

    //Init enumerator position
    if (!textEnum.MoveNext())
    {
        return "";
    }

    var lastSrcIndex = 0;
    var destIndex = length - 1;

    //Copy up the first surrogate found
    while (lastSrcIndex < srcIndex)
    {
        sb[destIndex] = expression[lastSrcIndex];
        destIndex -= 1;
        lastSrcIndex += 1;
    }

    //Now iterate through the text elements and copy them to the reversed string
    var nextSrcIndex = textEnum.ElementIndex;

    while (destIndex >= 0)
    {
        srcIndex = nextSrcIndex;

        //Move to next element
        nextSrcIndex = (textEnum.MoveNext()) ? textEnum.ElementIndex : length;
        lastSrcIndex = nextSrcIndex - 1;

        while (lastSrcIndex >= srcIndex)
        {
            sb[destIndex] = expression[lastSrcIndex];
            destIndex -= 1;
            lastSrcIndex -= 1;
        }
    }

    return sb.ToString();
}

Maaf karena memposting di utas lama ini. Saya berlatih beberapa kode untuk wawancara.

Inilah yang saya buat untuk C #. Versi pertama saya sebelum refactoring mengerikan.

static String Reverse2(string str)
{
    int strLen = str.Length, elem = strLen - 1;
    char[] charA = new char[strLen];

    for (int i = 0; i < strLen; i++)
    {
        charA[elem] = str[i];
        elem--;
    }

    return new String(charA);
}

Berbeda dengan Array.Reversemetode di bawah ini, ini muncul lebih cepat dengan 12 karakter atau kurang di string. Setelah 13 karakter, Array.Reversepermulaan menjadi lebih cepat, dan pada akhirnya mendominasi kecepatan. Saya hanya ingin menunjukkan kira-kira di mana kecepatan mulai berubah.

static String Reverse(string str)
{     
    char[] charA = str.ToCharArray();

    Array.Reverse(charA);

    return new String(charA);
}

Pada 100 karakter dalam string, ini lebih cepat daripada versi saya x 4. Namun, jika saya tahu bahwa string akan selalu kurang dari 13 karakter, saya akan menggunakan yang saya buat.

Pengujian dilakukan dengan Stopwatchdan iterasi 500.000. Juga, saya tidak yakin apakah versi saya menangani Pengganti atau situasi karakter gabungan dengan Unicodepenyandian.

"Cara yang lebih baik" tergantung pada apa yang lebih penting bagi Anda dalam situasi, kinerja, keanggunan, pemeliharaan, dll.

Bagaimanapun, inilah pendekatan menggunakan Array. Revers:

string inputString="The quick brown fox jumps over the lazy dog.";
char[] charArray = inputString.ToCharArray(); 
Array.Reverse(charArray); 

string reversed = new string(charArray);

Jika pernah muncul dalam sebuah wawancara dan Anda diberitahu bahwa Anda tidak dapat menggunakan Array. Dibalik, saya pikir ini mungkin salah satu yang tercepat. Itu tidak membuat string baru dan hanya mengulangi lebih dari setengah dari array (yaitu O (n / 2) iterasi)

    public static string ReverseString(string stringToReverse)
    {
        char[] charArray = stringToReverse.ToCharArray();
        int len = charArray.Length-1;
        int mid = len / 2;

        for (int i = 0; i < mid; i++)
        {
            char tmp = charArray[i];
            charArray[i] = charArray[len - i];
            charArray[len - i] = tmp;
        }
        return new string(charArray);
    }

Jika Anda memiliki string yang hanya berisi karakter ASCII, Anda dapat menggunakan metode ini.

    public static string ASCIIReverse(string s)
    {
        byte[] reversed = new byte[s.Length];

        int k = 0;
        for (int i = s.Length - 1; i >= 0; i--)
        {
            reversed[k++] = (byte)s[i];
        }

        return Encoding.ASCII.GetString(reversed);
    }

Pertama-tama apa yang harus Anda pahami adalah bahwa str + = akan mengubah ukuran memori string Anda untuk membuat ruang untuk 1 karakter tambahan. Ini baik-baik saja, tetapi jika Anda memiliki, katakanlah, sebuah buku dengan 1000 halaman yang ingin Anda balikkan, ini akan sangat lama untuk dieksekusi.

Solusi yang mungkin disarankan beberapa orang adalah menggunakan StringBuilder. Apa yang dilakukan pembuat string ketika Anda menjalankan + = adalah bahwa ia mengalokasikan potongan memori yang jauh lebih besar untuk menampung karakter baru sehingga tidak perlu melakukan realokasi setiap kali Anda menambahkan char.

Jika Anda benar-benar menginginkan solusi cepat dan minimal, saya sarankan yang berikut ini:

            char[] chars = new char[str.Length];
            for (int i = str.Length - 1, j = 0; i >= 0; --i, ++j)
            {
                chars[j] = str[i];
            }
            str = new String(chars);

Dalam solusi ini ada satu alokasi memori awal ketika char [] diinisialisasi dan satu alokasi ketika konstruktor string membangun string dari array char.

Di sistem saya, saya menjalankan tes untuk Anda yang membalik string 2 750 000 karakter. Berikut adalah hasil untuk 10 eksekusi:

StringBuilder: kutu 190K - 200K

Array Array: 130K - 160K ticks

Saya juga menjalankan tes untuk String normal + = tetapi saya meninggalkannya setelah 10 menit tanpa output.

Namun, saya juga memperhatikan bahwa untuk string yang lebih kecil, StringBuilder lebih cepat, jadi Anda harus memutuskan implementasi berdasarkan input.

Bersulang

public static string reverse(string s) 
{
    string r = "";
    for (int i = s.Length; i > 0; i--) r += s[i - 1];
    return r;
}

public static string Reverse2(string x)
        {
            char[] charArray = new char[x.Length];
            int len = x.Length - 1;
            for (int i = 0; i <= len; i++)
                charArray[i] = x[len - i];
            return new string(charArray);
        }