也来纠结一下字符串翻转

class Program
{
    static void Main(string[] args)
    {
        Program p = new Program();
        string r = p.ReverseString("5毛1234\0");
        r = p.ReverseString(string.Empty);
        r = p.ReverseString("1234567890",0,9);

        Console.ReadKey();
    }

    /// <summary>
    /// 翻转字符串，效率比较高，时间复杂度O(n/2)
    /// 由此引申出更灵活的实现，见下方重载
    /// </summary>
    public string ReverseString(string s)
    {
        if (s == null)
        {
            return null;
        }

        int len = s.Length;
        char[] charArray = s.ToArray();
        for (int i = 0; i < len / 2; i++)
        {
            char temp = charArray[i];
            charArray[i] = charArray[len - i - 1];
            charArray[len - i - 1] = temp;
        }

        return new string(charArray);
    }

    /// <summary>
    /// 可以翻转指定范围子串
    /// 于是之上的Reverse可复用该方法：Reverse(s,0,s.Length)
    /// </summary>
    /// <param name="s">待翻转字符串</param>
    /// <param name="start">起始位置</param>
    /// <param name="end">结束为止</param>
    /// <returns></returns>
    public string ReverseString(string s,int start,int end)
    {
        if (string.IsNullOrEmpty(s) || s.Length==1)
        {
            return s;
        }

        if (s.Length <= end)
        {
            throw new ArgumentException("end should be less than string length");
        }

        if (start < 0)
        {
            throw new ArgumentException("start should be larger than 0 or equal to 0");
        }

        if (start >= end)
        {
            throw new ArgumentException("start should be less than end");
        }

        char[] charArray = s.ToArray();
        for (int i = start; i <(start+end+1)/2; i++)
        {
            char temp = charArray[i];
            charArray[i]=charArray[end-i+start];
            charArray[end-i+start] = temp;
        }
        return new string(charArray);
    }

    /// <summary>
    /// 别忘了我们是在C# Coding！需要这么原始嘛？
    /// Array本身就有反转的方法
    /// </summary>
    public string ReverseString_Simple(string s, int start, int end)
    {
        if (string.IsNullOrEmpty(s))
        {
            return s;
        }
        char[] charArray = s.ToArray();

        return new string(charArray.Reverse().ToArray());
    }

    /*****
    *难道对类库本身的实现不感兴趣嘛？当然No！
    *我们看到类库的实现如下，和之上的实现思想毫无二致
    public static void Reverse(Array array, int index, int length)
    {
        if (array == null)
        {
            throw new ArgumentNullException("array");
        }
        if ((index < array.GetLowerBound(0)) || (length < 0))
        {
            throw new ArgumentOutOfRangeException((index < 0) ? "index" : "length", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
        }
        if ((array.Length - (index - array.GetLowerBound(0))) < length)
        {
            throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
        }
        if (array.Rank != 1)
        {
            throw new RankException(Environment.GetResourceString("Rank_MultiDimNotSupported"));
        }
        if (!TrySZReverse(array, index, length))
        {
            int num = index;
            int num2 = (index + length) - 1;
            object[] objArray = array as object[];
            if (objArray == null)
            {
                while (num < num2)
                {
                    object obj3 = array.GetValue(num);
                    array.SetValue(array.GetValue(num2), num);
                    array.SetValue(obj3, num2);
                    num++;
                    num2--;
                }
            }
            else
            {
                while (num < num2)
                {
                    object obj2 = objArray[num];
                    objArray[num] = objArray[num2];
                    objArray[num2] = obj2;
                    num++;
                    num2--;
                }
            }
        }
    }

    如果你还纠结TrySZReverse，
    打开Rotor，可以看到TrySZReverse的native实现映射到这样一个函数
    static void Reverse(KIND array[], UINT32 index, UINT32 count) {
        LEAF_CONTRACT;

        _ASSERTE(array != NULL);
        if (count == 0) {
            return;
        }
        UINT32 i = index;
        UINT32 j = index + count - 1;
        while(i < j) {
            KIND temp = array[i];
            array[i] = array[j];
            array[j] = temp;
            i++;
            j--;
        }
    }
    *****/
}