倒置字符数组中的字符

问题：如何把字符串 “We are the world” 转成 “world the are we” ？如果最多只能用两个额外的变量又该如何实现这样的转换？

分析：1.把字符串转成字符数组，然后对字符数组进行操作。

2.选择倒置字符数组的方法：用一个临时变量temp来交换两个字符，然后依次移动数组中的其他元素；利用 A=A+B, B=A-B, A=A-B 方式来交换两个字符。

3.根据数组中首尾字符的位置来倒置它们之间的字符。

4.优化方法：减少循环的次数，减少变量的个数。

C#代码：

using System.Linq;namespace MyTest
{    /// <summary>
    /// 用最少的变量和最高的效率实现：    /// 把"we are the world"倒置成"world the are we"    /// </summary>
    public class Program
    {        static void Main(string[] args)
        {            //待处理的字符串
            string myStr = "we are the world";

            System.Console.WriteLine("原始字符串：{0}", myStr);
            System.Console.WriteLine("一般方法的处理结果：{0}", ReverseOld(myStr.ToArray()));
            System.Console.WriteLine("改进方法的处理结果：{0}", ReverseNew(myStr.ToArray()));

            System.Console.ReadKey();
        }        /// <summary>
        /// 倒置字符数组，一般方法        /// 缺点：1.利用了多个变量，如temp,start,循环变量i,j        /// 2.最高有三层循环        /// </summary>
        /// <param name="arr">被倒置的字符数组</param>
        /// <returns>倒置后的字符数组</returns>
        static string ReverseOld(char[] arr)
        {            //暂存数组中的某个字符
            char temp = ‘ ‘;            //倒置某个单词时需要一个起始位置
            int start = -1;            //第一步：倒置整个字符数组
            for (int i = 0; i < arr.Length; i++)
            {
                temp = arr[arr.Length - 1];                for (int j = 0; j < arr.Length - i - 1; j++)
                {
                    arr[arr.Length - j - 1] = arr[arr.Length - j - 2];
                }
                arr[i] = temp;
            }            //第二步：倒置字符数组中的空格前的某个单词            
            for (int i = 0; i < arr.Length; i++)
            {                //遇到一个空格，就倒置空格前的一个单词
                if (arr[i] == ‘ ‘)
                {                    for (int j = start + 1; j < i; j++)
                    {
                        temp = arr[i - 1];                        for (int k = 0; k < i - j - 1; k++)
                        {
                            arr[i - k - 1] = arr[i - k - 2];
                        }
                        arr[j] = temp;
                    }
                    start = i;
                }
            }            //第三步：倒置字符数组中的最后一个单词
            for (int i = arr.Length - 1; i >= 0; i--)
            {                //遇到一个空格，就倒置空格前的一个单词
                if (arr[i] == ‘ ‘)
                {                    for (int j = i + 1; j < arr.Length - 1; j++)
                    {
                        temp = arr[arr.Length - 1];                        for (int k = 0; k < arr.Length - i - 2; k++)
                        {
                            arr[arr.Length - k - 1] = arr[arr.Length - k - 2];
                        }
                        arr[j] = temp;
                    }                    //最后一个单词倒置完毕，跳出循环
                    break;
                }
            }            //返回字符串
            return new string(arr);
        }        /// <summary>
        /// 倒置字符数组，改进后的方法        /// 改进地方：1.只利用一个额外的变量start和一个循环变量end        /// 2.循环次数大大减少        /// </summary>
        /// <param name="arr">被倒置的字符数组</param>
        /// <returns>倒置后的字符数组</returns>
        static string ReverseNew(char[] arr)
        {            //第一步：把整个字符数组倒置
            reverseWord(arr, 0, arr.Length);            //记录某个单词的起始位置
            int start = 0;            //第二步：依次倒置字符数组中的某个单词（不包括最后一个单词）
            for (int end = 0; end < arr.Length; end++)
            {                if (arr[end] == ‘ ‘)
                {
                    reverseWord(arr, start, end);
                    start = end + 1;
                }
            }            //第三步：倒置字符数组中的最后一个单词
            for (int end = arr.Length - 1; end > 0; end--)
            {                if (arr[end] == ‘ ‘)
                {
                    reverseWord(arr, end + 1, arr.Length);                    break;
                }
            }            //返回字符串
            return new string(arr);
        }        /// <summary>
        /// 倒置字符数组中，起始位置和结束位置之间的字符        /// </summary>
        /// <param name="arr">字符数组</param>
        /// <param name="start">起始位置</param>
        /// <param name="end">结束位置</param>
        static void reverseWord(char[] arr, int start, int end)
        {            //倒置整个字符数组
            for (int i = start; i < (start + end) / 2; i++)
            {                //交换两个整型变量的思路： a = a + b, b = a - b, a = a - b
                arr[i] = (char)(arr[i] + arr[start + end - i - 1]);
                arr[start + end - i - 1] = (char)(arr[i] - arr[start + end - i - 1]);
                arr[i] = (char)(arr[i] - arr[start + end - i - 1]);
            }
        }
    }
}

 运行结果：

原始字符串：we are the world

一般方法的处理结果：world the are we

改进方法的处理结果：world the are we