华为OJ 字符串排序

一 题目

二 解法

解法一：（1）将字母和其他字符分离；（2）对字母进行排序（稳定的排序算法）；（3）将排好序的字母与其他的字符合并。

//代码实现一，借鉴别人代码
//使用TreeSet对MyCharacter排序，其中MyCharacter实现了Comparable接口
import java.util.Iterator;  
import java.util.Scanner;  
import java.util.TreeSet;  



public class Main{  
    public static void main(String[]args){  
        Scanner scanner = new Scanner(System.in);  
        String string  = scanner.nextLine();  
        TreeSet<MyCharacter> rr = new TreeSet<MyCharacter>();     
        char[] ee = new char[string.length()] ;  
        for(int i=0;i<string.length();i++){  
            if(Character.isLetter(string.charAt(i))){  
                MyCharacter  m = new MyCharacter(string.charAt(i));  
                rr.add(m);  
            }else{  
                ee[i]=string.charAt(i);  
            }  
        }  
        Iterator<MyCharacter> i = rr.iterator();  
        for(int j=0;j<ee.length;j++){  
            if(ee[j]==0){  
                ee[j]=i.next().c;  
                System.out.print(ee[j]);  
            }else{  
                System.out.print(ee[j]);  
            }  
        }  

    }  

    static  class MyCharacter  implements Comparable{  
        public char c;  

        public MyCharacter(char c){  
            this.c=c;  
        }  

        @Override  
        public int compareTo(Object o) {  
             MyCharacter other = (MyCharacter)o;  

             if( Character.isLetter(this.c)&&Character.isLetter(other.c)){  
                 if (Character.toLowerCase(this.c)-Character.toLowerCase(other.c)>=0)    

                        return 1;    
                 else  
                        return -1;    
             }  


             return 0;  
        }  

    }  
}  

//代码实现二 借鉴别人代码
//使用Java提供的Collections.sort(...)排序
import java.util.ArrayList;  
import java.util.Collections;  
import java.util.Comparator;  
import java.util.Scanner;  

public class Main {  
    public static void main(String[] args) {  
        Scanner aScanner = new Scanner(System.in);  
        String input = aScanner.nextLine();  
        ArrayList<Character> list = new ArrayList<Character>();  
        ArrayList<Integer> index_list = new ArrayList<Integer>();  
        for (int i = 0; i < input.length(); i++) {  
            if (Character.isUpperCase(input.charAt(i))  
                    || Character.isLowerCase(input.charAt(i))) {  
                list.add(input.charAt(i));  
                index_list.add(i);  
            }  
        }  
        Collections.sort(list, new Comparator<Character>() {  
            @Override  
            public int compare(Character o1, Character o2) {  
                // TODO Auto-generated method stub  
                return String.valueOf(o1).toLowerCase()  
                        .compareTo(String.valueOf(o2).toLowerCase());  
            }  
        });  
        for (int j = 0; j < index_list.size(); j++) {  
            input = input.substring(0, index_list.get(j)) + list.get(j)  
                    + input.substring(index_list.get(j) + 1);  
        }  
        System.out.println(input);  
    }  
} 

解法二：（1）String转化字符数组；（2）选择稳定的排序算法对字符数组排序，排序时跳过除字母外的其他字符；（3）字符数组转化String，输出String。

//代码实现 自己做的
//直接插入排序，排序时跳过非字母字符
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sin=new Scanner(System.in);
        String inStr=sin.nextLine();
        char [] string=inStr.toCharArray();
        char sentry;
        int i=0;
        while(i<string.length)
        {
            while(i<string.length&&!isLetter(string[i]))
            {
                i++;
            }
            int inm1=i;
            i++;
            while(i<string.length&&!isLetter(string[i]))
            {
                i++;
            }
            int in=i;
            if(i>=string.length) 
                {
                break;
                }
            if(compare(string[inm1],string[in])>0)
            {
                sentry=string[in];
                int j=in,jn=in;
                while(j>=0)
                {
                    jn=j;
                    j--;
                    while(j>=0&&!isLetter(string[j]))
                    {
                        j--;
                    }
                    if(j<0) {
                        break;
                    }
                    if(compare(string[j],sentry)>0)
                    {
                        string[jn]=string[j];
                    }
                    else break;
                }
                string[jn]=sentry;
            }
        }
        String outStr=new String(string);
        System.out.println(outStr);
    }
    private static boolean isLetter(char c)
    {
        return ((c>='A'&&c<='Z')||(c>='a'&&c<='z'))?true:false;
    }
    private static int compare(char a,char b)
    {
        int an=0,bn=0;
        if(a>='A'&&a<='Z') {an=a-'A';}
        else if(a>='a'&&a<='z') {an=a-'a';}
        if(b>='A'&&b<='Z') {bn=b-'A';}
        else if(b>='a'&&b<='z') {bn=b-'a';}
        return an-bn;
    }
}

三 反思

相较于解法一，解法二有如下不足：

（1）解法二太过于蛮力，没有技巧性;
（2）解法二缺乏面向对象的编程思考；
（3）嵌套太深，圈复杂度太高；
（4）实现上没有使用一些高级的容器和Java提供的算法，Java编程基础还不牢固；
（5）难以理解，编程容易出错。