空间复杂度为1的从右向左显示

    public void doTest(View view){
        String TAG = "kodulf";

//        请给出算法，要求空间复杂度为1
//        部分国家是从右向做阅读的，要求给出算法，将下面的message 转化为从右向左的
//        例如："hello world" 就转为 "world hello"
//        例如："are you ok" 就转为"ok you are"

        char[] message = {'h','e','l','l','o',' ','w','o','r','l','d'};
        char[] message2 = {'a','r','e',' ','y','o','u',' ','o','k'};


        test(message);
        Log.d(TAG,"message :" + new String(message));


        test(message2);
        Log.d(TAG,"message2 :" + new String(message2));
    }

    public void test(char[] message){
        String TAG = "kodulf";
        int length = message.length;
        //1：先整体调换
        reverse(message,0,message.length-1);

        int start = 0;

        for (int i = 0; i < message.length; i++) {
            if (message[i]== ' '){
                Log.d(TAG,"message-mid : " + "start = " +start + " i = " + i);
                reverse(message,start,i-1);
                Log.d(TAG,"message-mid :" + new String(message) + "start = " +start);
                start = i+1;
                Log.d(TAG,"message-mid :" + "start = " +start);
            }
        }
    }

    public void reverse(char[] message, int start, int end){
        String TAG = "kodulf";
        Log.d(TAG,"reverse :" + "start = " +start + " end =  "+ end + " message = " +new String(message));
        char temp;
        for (int i = start; i <=((start+end)/2); i++) {
            temp = message[i];
            //这里这一步很重要就是要+start，否则中间的一些单纯就会有问题，因为例如3，5之间，如果直接end-i就是5-3 = 2了。
            message[i] = message[end -i + start];
            message[end -i + start] = temp;
        }
    }

豆包给出的：

public class ReverseWordsInArray {
    public static void reverseWords(char[] message) {
        // 先整体反转字符数组
        reverse(message, 0, message.length - 1);

        int start = 0;
        int end;
        // 再逐个反转每个单词
        while (start < message.length) {
            end = start;
            while (end < message.length && message[end]!= ' ') {
                end++;
            }
            reverse(message, start, end - 1);
            start = end + 1;
        }
    }

    private static void reverse(char[] arr, int start, int end) {
        while (start < end) {
            char temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
            start++;
            end--;
        }
    }

    public static void main(String[] args) {
        char[] message1 = {'h','e','l','l','o',' ','w','o','r','l','d'};
        reverseWords(message1);
        System.out.println(new String(message1));

        char[] message2 = {'a','r','e',' ','y','o','u',' ','o','k'};
        reverseWords(message2);
        System.out.println(new String(message2));
    }
}
这个算法首先整体反转整个字符数组，然后逐个反转每个单词，从而实现将字符串从左向右的顺序转换为从右向左的顺序，且空间复杂度为 O (1)，只使用了有限的额外变量，不随输入规模的增加而增加额外的空间需求。