我刚刚不得不在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;
}
就我个人而言，我并不热衷于这个函数，并且确信有更好的方法来完成它。有吗？
string inputString="The quick brown fox jumps over the lazy dog.";
char[] charArray = inputString.ToCharArray();
Array.Reverse(charArray);
string reversed = new string(charArray);
我需要提交一个递归的例子：
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));
}
我从Microsoft.VisualBasic.Strings中翻译了一个C#版本。我不确定为什么他们把这些有用的函数（来自VB）放在Framework的System.String之外，但仍在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();
}
string s = "abo\u0327\u0307\u035d\U0001d166cd"，其中包含字母 o 后面跟着 BMP 中的 3 个组合变音符号和来自天界平面（非 BMP）的一个组合符号（MUSICAL SYMBOL COMBINING STEM），它可以保持它们的完整性。但是如果这样的字符仅出现在长字符串的末尾，则该方法速度较慢，因为它必须两次遍历整个数组。 - Abel基于堆栈的解决方案。
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);
}
由于我喜欢其中一种答案-使用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;
}
});
}
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
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);
}
x无关的因子（在您的情况下是n）不会被使用。算法的性能为 f(x) = x + ½x + C，其中C是一些常数。由于C和1½因子都不依赖于x，因此您的算法是O(x)。这并不意味着它不会对任何长度为x的输入更快，但其性能是线性依赖于输入长度的。回答@MarcelValdezOrozco，是的，它也是O(n)，尽管它每次复制16字节块以提高速度（它不使用总长度的直接memcpy）。 - Abel很抱歉在这个旧帖中发布。我正在为一次面试练习编写代码。
以下是我用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个字符时，这个版本比我的版本快4倍。然而，如果我知道字符串总是少于13个字符，我会使用我做的那个。
测试是使用Stopwatch和5000000次迭代完成的。另外，我不确定我的版本是否处理了使用Unicode编码的替代和组合字符情况。
public static string reverse(string s)
{
string r = "";
for (int i = s.Length; i > 0; i--) r += s[i - 1];
return r;
}
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);
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);
}