1451. 重新排列句子中的单词

https://leetcode-cn.com/problems/rearrange-words-in-a-sentence/

非常简单的题目，首先先将字符串按照空格进行分割，然后将第一个字符串的首字母转成小写。

然后对字符串数组进行排序，按照字符串的长度进行排序，因为题目要求要保持原有的顺序，所以我采用了最简单的冒泡排序进行编写。

排序完后，对第一个字符串的首字母进行大写化，然后用StringBuilder一个一个添加回去即可。

执行结果：

执行用时 :1017 ms, 在所有 Java 提交中击败了100.00%的用户

内存消耗 :40.8 MB, 在所有 Java 提交中击败了100.00%的用户

class Solution {
    public String arrangeWords(String text) {
        String[] str = text.trim().split(" ");
        str[0] = str[0].toLowerCase();
        for(int i = 0; i < str.length; i++){
            for(int j = 0; j < str.length - i - 1; j++){
                if(str[j].length() > str[j+1].length()){
                    String temp = str[j];
                    str[j] = str[j+1];
                    str[j+1] = temp;
                }
            }
        }
        str[0] = str[0].substring(0,1).toUpperCase() + str[0].substring(1);
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < str.length; i++){
            sb.append(str[i]);
            if(i != str.length -1){
                sb.append(" ");
            }
        }
        return sb.toString();
    }
}

当然，看了评论区的题解后，我才知道原来Java自带的Arrays.sort()排序方法本身就是稳定的，所以就优化成了下面这个样子。

class Solution {
    public String arrangeWords(String text) {
        String[] str = text.trim().split(" ");
        str[0] = str[0].toLowerCase();
        Arrays.sort(str, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        });
        str[0] = str[0].substring(0,1).toUpperCase() + str[0].substring(1);
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < str.length; i++){
            sb.append(str[i]);
            if(i != str.length -1){
                sb.append(" ");
            }
        }
        return sb.toString();
    }
}

执行用时：28 ms

内存消耗：40.6 MB

 

看得出来Java自带的排序比手写的快了多少~~虽然我知道冒泡排序并不是稳定排序的最佳选择。

 

后续：我自己手写了一次归并排序，同时评论区也有人指出Arrays.sort(T[],Comparator<? super T> c) 内部采用的归并排序，因此是稳定的。Arrays.sort(int[] a) 内部采用的快速排序，因此是不稳定的。并且根据个人的代码来看，的确就是这个样子。

class Solution {
    public String arrangeWords(String text) {
        String[] str = text.trim().split(" ");
        str[0] = str[0].toLowerCase();
        str = mergeSort(str);
        str[0] = str[0].substring(0,1).toUpperCase() + str[0].substring(1);
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < str.length; i++){
            sb.append(str[i]);
            if(i != str.length -1){
                sb.append(" ");
            }
        }
        return sb.toString();
    }
    
    private String[] mergeSort(String[] str){
        if(str.length <= 1){
            return str;
        }
        String[] str1 = mergeSort(Arrays.copyOfRange(str,0,str.length/2));
        String[] str2= mergeSort(Arrays.copyOfRange(str,str.length/2,str.length));
        return merge(str1,str2);
    }
    
    private String[] merge(String[] str1, String[] str2){
        String[] str = new String[str1.length + str2.length];
        int i = 0;
        int j = 0;
        int index = 0;
        while(i < str1.length && j < str2.length){
            if(str1[i].length() > str2[j].length()){
                str[index++] = str2[j++];
            }else{
                str[index++] = str1[i++];
            }
        }
        while(i < str1.length){
            str[index++] = str1[i++];
        }
        while(j < str2.length){
            str[index++] = str2[j++];
        }
        return str;
    }
}