我只需要在C＃2.0中编写一个字符串反转函数（即LINQ不可用），并想出了这个：
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;
}
就个人而言，我并不是对这个功能感到疯狂，并且我相信有更好的方法可以做到这一点。有吗？
答案 0 :(得分：512)
public static string Reverse( string s )
{
char[] charArray = s.ToCharArray();
Array.Reverse( charArray );
return new string( charArray );
}
答案 1 :(得分：160)
这是一个正确地将字符串"Les Mise\u0301rables"反转为"selbare\u0301siM seL"的解决方案。这应该像selbarésiM seL，而不是selbaŕesiM seL（请注意重音的位置），以及基于代码单元（Array.Reverse等）或甚至代码点的大多数实现的结果（特别注意代理对的转换）。
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);
}
}
（现场运行示例：https://ideone.com/DqAeMJ）
它只是使用.NET API for grapheme cluster iteration，它曾经存在过，但看起来有点“隐藏”了。
答案 2 :(得分：123)
这是一个令人惊讶的棘手问题。
我建议在大多数情况下使用Array.Reverse，因为它是本地编码的，维护和理解非常简单。
在我测试的所有情况下，它似乎都优于StringBuilder。
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);
}
对于某些字符串长度uses 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);
}
注意如果要支持完整的Unicode UTF16字符集read this。而是使用那里的实现。它可以通过使用上述算法之一进行进一步优化，并在字符串反转后通过字符串进行清理。
这是StringBuilder，Array.Reverse和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();
}
}
}
结果如下：
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.
对于短字符串，Xor似乎更快。
答案 3 :(得分：49)
如果字符串包含Unicode数据（严格来说，非BMP字符），则已发布的其他方法将损坏它，因为在反转字符串时无法交换高和低代理代码单元的顺序。 （有关此内容的更多信息，请参见my blog。）
以下代码示例将正确反转包含非BMP字符的字符串，例如“\ U00010380 \ U00010381”（Ugaritic Letter Alpa，Ugaritic Letter 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);
}
答案 4 :(得分：45)
来自3.5 Framework
public string ReverseString(string srtVarable)
{
return new string(srtVarable.Reverse().ToArray());
}
答案 5 :(得分：23)
好的，为了“不要重复自己”，我提供了以下解决方案：
public string Reverse(string text)
{
return Microsoft.VisualBasic.Strings.StrReverse(text);
}
我的理解是这个实现，默认情况下在VB.NET中可用，正确处理Unicode字符。
答案 6 :(得分：17)
Greg Beech发布了一个unsafe选项，确实和它一样快（这是一个就地反转）;但是，正如他在答案中指出的那样，它是 a completely disastrous idea 。
那就是说，我很惊讶有很多共识，Array.Reverse是最快的方法。对于小字符串，仍然有unsafe方法返回字符串的反转副本（没有就地反转恶作剧）明显快于Array.Reverse方法：
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);
}
Here are some benchmark results
随着字符串变大，您可以看到性能增益收缩然后随Array.Reverse方法消失。但是对于中小型琴弦来说，很难击败这种方法。
答案 7 :(得分：14)
简单明了的答案是使用扩展方法：
static class ExtentionMethodCollection
{
public static string Inverse(this string @base)
{
return new string(@base.Reverse().ToArray());
}
}
以及输出：
string Answer = "12345".Inverse(); // = "54321"
答案 8 :(得分：12)
如果你想玩一个非常危险的游戏，那么这是迄今为止最快的方式（大约比Array.Reverse方法快四倍）。这是使用指针的就地反转。
请注意，我真的不建议将其用于任何用途（have a look here for some reasons why you should not use this method），但有趣的是看到它可以完成，并且一旦打开不安全的代码，字符串就不是真正不可变的
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;
}
}
答案 9 :(得分：11)
首先，您不需要调用ToCharArray，因为字符串已经被索引为char数组，因此这将为您节省分配。
下一个优化是使用StringBuilder来防止不必要的分配（因为字符串是不可变的，连接它们每次都会生成字符串的副本）。为了进一步优化这个，我们预先设置StringBuilder的长度，这样就不需要扩展它的缓冲区了。
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();
}
修改：效果数据
我使用Array.Reverse使用以下简单程序测试了此函数和函数，其中Reverse1是一个函数而Reverse2是另一个函数：
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();
}
事实证明，对于短字符串，Array.Reverse方法的速度大约是上面的两倍，而对于较长的字符串，差异甚至更明显。因此，假设Array.Reverse方法更简单，更快，我建议你使用它而不是这个。我把这个留在这里只是为了表明这不是你应该这样做的方式（令我惊讶的是！）
答案 10 :(得分：11)
查看维基百科条目here。它们实现String.Reverse扩展方法。这允许您编写如下代码：
string s = "olleh";
s.Reverse();
他们还使用ToCharArray / Reverse组合，这个问题的其他答案表明。源代码如下所示：
public static string Reverse(this string input)
{
char[] chars = input.ToCharArray();
Array.Reverse(chars);
return new String(chars);
}
答案 11 :(得分：10)
尝试使用Array.Reverse
public string Reverse(string str)
{
char[] array = str.ToCharArray();
Array.Reverse(array);
return new string(array);
}
答案 12 :(得分：10)
public static string Reverse(string input)
{
return string.Concat(Enumerable.Reverse(input));
}
当然你可以使用Reverse方法扩展字符串类
public static class StringExtensions
{
public static string Reverse(this string input)
{
return string.Concat(Enumerable.Reverse(input));
}
}
答案 13 :(得分：6)
不要打扰功能，只需这样做。注意：第二行将在某些VS版本的立即窗口中抛出一个参数异常。
string s = "Blah";
s = new string(s.ToCharArray().Reverse().ToArray());
答案 14 :(得分：5)
“最佳”可以取决于许多事情，但是这里有一些从快速到慢速排序的简短替代品：
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̽"
答案 15 :(得分：5)
必须提交一个递归示例：
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));
}
答案 16 :(得分：4)
很抱歉很长的帖子，但这可能很有意思
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");
}
}
}
结果：
答案 17 :(得分：4)
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();
}
}
<强>输出
尺寸：10
Naive Ticks: 1
Efficient linear Ticks: 0
Recursive Ticks: 2
DotNet Reverse Ticks: 1
尺寸：100
Naive Ticks: 2
Efficient linear Ticks: 1
Recursive Ticks: 12
DotNet Reverse Ticks: 1
尺寸：1000
Naive Ticks: 5
Efficient linear Ticks: 2
Recursive Ticks: 358
DotNet Reverse Ticks: 9
尺寸：10000
Naive Ticks: 32
Efficient linear Ticks: 28
Recursive Ticks: 84808
DotNet Reverse Ticks: 33
答案 18 :(得分：4)
基于堆栈的解决方案。
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);
}
或
public static string Reverse(string text)
{
var stack = new Stack<char>(text);
return string.Join("", stack);
}
答案 19 :(得分：3)
怎么样：
private string Reverse(string stringToReverse)
{
char[] rev = stringToReverse.Reverse().ToArray();
return new string(rev);
}
答案 20 :(得分：3)
很抱歉在这个旧帖子上发帖。我正在练习一些面试代码。
这就是我为C＃提出的。重构前的第一个版本很糟糕。
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);
}
与下面的Array.Reverse方法相比，字符串中的12个字符或更少字符显示得更快。在13个字符之后，Array.Reverse开始变得更快，并且它最终在速度上占据主导地位。我只是想指出速度开始变化的地方。
static String Reverse(string str)
{
char[] charA = str.ToCharArray();
Array.Reverse(charA);
return new String(charA);
}
字符串中有100个字符，它比我的版本x 4快。但是，如果我知道字符串总是少于13个字符，我会使用我制作的字符串。
使用Stopwatch和5000000次迭代进行测试。此外，我不确定我的版本是否使用Unicode编码处理代理或组合字符情况。
答案 21 :(得分：3)
我从Microsoft.VisualBasic.Strings创建了一个C＃端口。我不确定他们为什么在Framework中的System.String之外保留这些有用的函数（来自VB），但仍然在Microsoft.VisualBasic下。财务职能的相同方案（例如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();
}
答案 22 :(得分：2)
public static string reverse(string s)
{
string r = "";
for (int i = s.Length; i > 0; i--) r += s[i - 1];
return r;
}
答案 23 :(得分：2)
从.NET Core 2.1开始，有一种使用string.Create方法来反转字符串的新方法。
请注意，此解决方案无法正确处理Unicode组合字符等，因为“ Les Mise \ u0301rables”将转换为“selbarésiMseL”。 the other answers是一个更好的解决方案。
public static string Reverse(string input)
{
return string.Create<string>(input.Length, input, (chars, state) =>
{
state.AsSpan().CopyTo(chars);
chars.Reverse();
});
}
这实际上将input的字符复制到新字符串并就地反转新字符串。
string.Create为什么有用？当我们从现有数组创建字符串时，将分配一个新的内部数组并复制值。否则，有可能在创建字符串后（在安全的环境中）对字符串进行突变。也就是说，在下面的代码段中，我们必须分配一个长度为10的数组两次，一个作为缓冲区，一个作为字符串的内部数组。
var chars = new char[10];
// set array values
var str = new string(chars);
string.Create本质上允许我们在字符串创建期间操纵内部数组。也就是说，我们不再需要缓冲区，因此可以避免分配一个char数组。
史蒂夫·戈登（Steve Gordon）对此进行了更详细的介绍here。在MSDN上也有一篇文章。
string.Create？public static string Create<TState>(int length, TState state, SpanAction<char, TState> action);
该方法具有三个参数：
char数组，第二个参数是您传递给string.Create的数据（状态） 。在委托内部，我们可以指定如何从数据创建新字符串。在我们的例子中，我们只是将输入字符串的字符复制到新字符串使用的Span上。然后我们反转Span，因此整个字符串都反转了。
为了将我提出的反转字符串的方法与可接受的答案进行比较，我使用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);
}
这是我机器上的结果：
| 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 |
如您所见，使用ReverseWithStringCreate，我们仅分配ReverseWithArray方法使用的一半内存。
答案 24 :(得分：2)
如果您的字符串只包含ASCII字符，则可以使用此方法。
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);
}
答案 25 :(得分：2)
如果它在面试中出现并且你被告知你不能使用Array.Reverse，我认为这可能是最快的之一。它不会创建新的字符串，只迭代一半的数组（即O（n / 2）次迭代）
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);
}
答案 26 :(得分：2)
“更好的方式”取决于在您的情况，性能，优雅，可维护性等方面对您更重要的事情。
无论如何，这是使用Array.Reverse的方法：
string inputString="The quick brown fox jumps over the lazy dog.";
char[] charArray = inputString.ToCharArray();
Array.Reverse(charArray);
string reversed = new string(charArray);
答案 27 :(得分：1)
首先，您必须了解的是str + =将调整字符串内存的大小，以便为1个额外的char腾出空间。这很好，但是如果你有一本你想要翻转的1000页的书，这将需要很长时间才能执行。
有些人可能建议的解决方案是使用StringBuilder。执行+ =时，字符串生成器的作用是分配更大的内存块来保存新字符，这样每次添加char时都不需要重新分配。
如果您真的想要一个快速且极简的解决方案，我建议如下：
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);
在此解决方案中，初始化char []时有一个初始内存分配，当字符串构造函数从char数组构建字符串时有一个分配。
在我的系统上，我为你运行了一个测试，它反转了一个包含2 750 000个字符的字符串。以下是10次执行的结果：
StringBuilder：190K - 200K ticks
Char数组：130K - 160K滴答
我还测试了正常的String + =但是我在10分钟之后放弃了它而没有输出。
但是，我也注意到，对于较小的字符串，StringBuilder更快，因此您必须根据输入决定实现。
干杯
答案 28 :(得分：1)
private static string Reverse(string str)
{
string revStr = string.Empty;
for (int i = str.Length - 1; i >= 0; i--)
{
revStr += str[i].ToString();
}
return revStr;
}
比上述方法更快
private static string ReverseEx(string str)
{
char[] chrArray = str.ToCharArray();
int len = chrArray.Length - 1;
char rev = 'n';
for (int i = 0; i <= len/2; i++)
{
rev = chrArray[i];
chrArray[i] = chrArray[len - i];
chrArray[len - i] = rev;
}
return new string(chrArray);
}
答案 29 :(得分：1)
由于我喜欢几个答案-一个用于使用string.Create，因此高性能和低分配，另一个用于正确性-使用StringInfo类，我决定需要一种组合方法。这是最终的字符串反转方法：）
private static string ReverseString(string str)
{
return string.Create(str.Length, str, (chars, state) =>
{
var enumerator = StringInfo.GetTextElementEnumerator(state);
var position = state.Length;
while (enumerator.MoveNext())
{
var cluster = ((string)enumerator.Current).AsSpan();
cluster.CopyTo(chars.Slice(position - cluster.Length));
position -= cluster.Length;
}
});
}
使用StringInfo类的方法还有一种更好的方法，该方法仅返回索引就跳过了Enumerator分配的许多字符串。
private static string ReverseString(string str)
{
return string.Create(str.Length, str, (chars, state) =>
{
var position = 0;
var indexes = StringInfo.ParseCombiningCharacters(state); // skips string creation
var stateSpan = state.AsSpan();
for (int len = indexes.Length, i = len - 1; i >= 0; i--)
{
var index = indexes[i];
var spanLength = i == len - 1 ? state.Length - index : indexes[i + 1] - index;
stateSpan.Slice(index, spanLength).CopyTo(chars.Slice(position));
position += spanLength;
}
});
}
与LINQ解决方案相比的一些基准测试：
String length 20:
LINQ Mean: 2,355.5 ns Allocated: 1440 B
string.Create Mean: 851.0 ns Allocated: 720 B
string.Create with indexes Mean: 466.4 ns Allocated: 168 B
String length 450:
LINQ Mean: 34.33 us Allocated: 22.98 KB
string.Create Mean: 19.13 us Allocated: 14.98 KB
string.Create with indexes Mean: 10.32 us Allocated: 2.69 KB
答案 30 :(得分：1)
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);
}
答案 31 :(得分：1)
使用LINQ的汇总功能
string s = "Karthik U";
s = s.Aggregate(new StringBuilder(), (o, p) => o.Insert(0, p)).ToString();
答案 32 :(得分：1)
这很简单：
string x = "your string";
string x1 = "";
for(int i = x.Length-1 ; i >= 0; i--)
x1 += x[i];
Console.WriteLine("The reverse of the string is:\n {0}", x1);
请参阅output。
答案 33 :(得分：1)
这是一个unicode安全版本的函数，写成一个可以安全地处理unicode的扩展。它接近标记的完整答案，但不会抛出“无效的高代理人字符”的例外。
public static class StringExtensions
{
public static string Reverse(this string s)
{
var info = new StringInfo(s);
var charArray = new char[s.Length];
var teIndices = StringInfo.ParseCombiningCharacters(s).Reverse();
int j = 0;
foreach(var i in teIndices)
{
if (char.IsHighSurrogate(s[i]))
{
charArray[j] = s[i];
j++;
charArray[j] = s[i+1];
}
else
{
charArray[j] = s[i];
}
j++;
}
return new string(charArray);
}
}
答案 34 :(得分：1)
如何使用Substring
static string ReverseString(string text)
{
string sub = "";
int indexCount = text.Length - 1;
for (int i = indexCount; i > -1; i--)
{
sub = sub + text.Substring(i, 1);
}
return sub;
}
答案 35 :(得分：1)
最简单的方法：
string reversed = new string(text.Reverse().ToArray());
答案 36 :(得分：0)
如果有人询问反向字符串，其目的可能是找出您是否知道诸如XOR之类的按位运算。在C＃中，您具有Array.Reverse函数，但是，您可以在几行代码（最小）中使用简单的XOR操作
public static string MyReverse(string s)
{
char[] charArray = s.ToCharArray();
int bgn = -1;
int end = s.Length;
while(++bgn < --end)
{
charArray[bgn] ^= charArray[end];
charArray[end] ^= charArray[bgn];
charArray[bgn] ^= charArray[end];
}
return new string(charArray);
}
答案 37 :(得分：0)
string original = "Stack Overflow";
string reversed = new string(original.Reverse().ToArray());
答案 38 :(得分：0)
处理所有类型的unicode字符
使用System.Globalization;
public static string ReverseString(this string content) {
var textElementEnumerator = StringInfo.GetTextElementEnumerator(content);
var SbBuilder = new StringBuilder(content.Length);
while (textElementEnumerator.MoveNext()) {
SbBuilder.Insert(0, textElementEnumerator.GetTextElement());
}
return SbBuilder.ToString();
}
答案 39 :(得分：0)
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication1
{
class Program
{
public static string ReverseString(string str)
{
int totalLength = str.Length;
int iCount = 0;
string strRev = string.Empty;
iCount = totalLength;
while (iCount != 0)
{
iCount--;
strRev += str[iCount];
}
return strRev;
}
static void Main(string[] args)
{
string str = "Punit Pandya";
string strResult = ReverseString(str);
Console.WriteLine(strResult);
Console.ReadLine();
}
}
}
答案 40 :(得分：0)
testCompile - Dependencies for source set 'test' (deprecated, use 'testImplementation ' instead).
\--- project :json-display
\--- com.google.code.gson:gson:2.8.0
BU¦LD SUCCESSFUL in 1s
1 actionable task: 1 executed
答案 41 :(得分：0)
有多种方法可以反转字符串，我在下面显示了3个。
- 使用Array.Reverse函数。
private static string ReverseString1(string text)
{
char[] rtext = text.ToCharArray();
Array.Reverse(rtext);
return new string(rtext);
}
- 仅使用字符串
private static string ReverseString2(string text)
{
String rtext = "";
for (int i = text.Length - 1; i >= 0; i--)
{
rtext = rtext + text[i];
}
return rtext;
}
- 仅使用char数组
public static string ReverseString3(string str)
{
char[] chars = str.ToCharArray();
char[] rchars = new char[chars.Length];
for (int i = 0, j = str.Length - 1; i < chars.Length; i++, j--)
{
rchars[j] = chars[i];
}
return new string(rchars);
}
答案 42 :(得分：-1)
在采访中我被问到了类似的问题。这是我的回答，虽然它的表现可能没有其他答案那么快。我的问题被称为“创建一个可以使用方法向后打印字符串的类”：
using System;
using System.Collections.Generic;
using System.Linq;
namespace BackwardsTest
{
class PrintBackwards
{
public static void print(string param)
{
if (param == null || param.Length == 0)
{
Console.WriteLine("string is null");
return;
}
List<char> list = new List<char>();
string returned = null;
foreach(char d in param)
{
list.Add(d);
}
for(int i = list.Count(); i > 0; i--)
{
returned = returned + list[list.Count - 1];
list.RemoveAt(list.Count - 1);
}
Console.WriteLine(returned);
}
}
class Program
{
static void Main(string[] args)
{
string test = "I want to print backwards";
PrintBackwards.print(test);
System.Threading.Thread.Sleep(5000);
}
}
}
答案 43 :(得分：-1)
string A = null;
//a now is reversed and you can use it
A = SimulateStrReverse.StrReverse("your string");
public static class SimulateStrReverse
{
public static string StrReverse(string expression)
{
if (string.IsNullOrEmpty(expression))
return string.Empty;
string reversedString = string.Empty;
for (int charIndex = expression.Length - 1; charIndex >= 0; charIndex--)
{
reversedString += expression[charIndex];
}
return reversedString;
}
}
答案 44 :(得分：-2)
这是用于反向字符串的代码
public Static void main(){
string text = "Test Text";
Console.Writeline(RevestString(text))
}
public Static string RevestString(string text){
char[] textToChar = text.ToCharArray();
string result= string.Empty;
int length = textToChar .Length;
for (int i = length; i > 0; --i)
result += textToChar[i - 1];
return result;
}
答案 45 :(得分：-3)
这很简单
static void Reverse()
{
string str = "PankajRawat";
var arr = str.ToCharArray();
for (int i = str.Length-1; i >= 0; i--)
{
Console.Write(arr[i]);
}
}
答案 46 :(得分：-4)
public string rev(string str)
{
if (str.Length <= 0)
return string.Empty;
else
return str[str.Length-1]+ rev(str.Substring(0,str.Length-1));
}
答案 47 :(得分：-5)
在不使用新字符串的情况下反转字符串。让我们说
String input = "Mark Henry";
//Just to convert into char array. One can simply take input in char array.
Char[] array = input.toCharArray(input);
int a = input.length;
for(int i=0; i<(array.length/2 -1) ; i++)
{
array[i] = array[i] + array[a];
array[a] = array[i] - array[a];
array[i] = array[i] - array[a--];
}
答案 48 :(得分：-8)
SELECT REVERSE('somestring');
完成。