Question

我目前正在用Java开发自然排序算法。要求是使其运行迅速。给定输入字符串列表[1 !, 10 !, 100，100 !, 2]。预期的输出顺序为[1 !, 2，10！，100，100！]。如您所见，它们首先对数字编号进行排序，然后对值进行比较。但是，在设计案例时让我头疼。

这是设计此问题时的想法。

给出字符串a，b。
（编辑：输入值可能是100！90！10！1234，其中带有多个“！”。很抱歉，前面没有提到。输入也将带有英文字母。但是当前版本可以像老板一样处理它）

我创建四个索引(ind_a1, ind_a2, ind_b1, ind_b2)

情况1：如果ind_a1或ind_b1触摸!，然后返回-1

情况2：如果ind_a1或ind_b1触摸字符串的末尾-1返回-1（当前的问题在案例2中就出现了）

情况3：当两个索引都触摸!时，

案例3.1：检查是否a.substring(ind_a2, ind_a1) == (b.substring(ind_b2, ind_b1) 如果它们相等，则表示先前的值相同。例如： 1258!100和1258!10。 a.substring(ind_a2, ind_a1) = (b.substring(ind_b2, ind_b1) = 1258

情况3.2：如果它们不相等，则仅返回先前的比较值。

这是我的完整代码。

public int compare(String a, String b) {
        int ind_a1 = 0 ,ind_a2 = 0;
        int ind_b1 = 0 ,ind_b2 = 0;
        int length_a = a.length();
        int length_b = b.length();
        int result = a.compareTo(b);
        char char_a, char_b;


        while(true)
        {
            char_a = a.charAt(ind_a1);
            char_b = b.charAt(ind_b1);
            //check if a or b is an empty String
            if(length_a == 0 || length_b ==0) {
                return length_a - length_b;
            }

            //Case 1）
            if(char_a == '!' && char_b != '!') {
                return -1;
            }
            if(char_b == '!' && char_a != '!') {
                return +1;
            }
            //Case 2: I NEED HELP HERE
            if(ind_a1 == length_a-1 || ind_b1 == length_b-1 ) {
                return length_a - length_b;
            }

            //Case 2 corner case, if both string has same length
            if(length_a == length_b) {
                return result;
            }

            //Case 3, if both index touch "!"   
            if(char_a =='!' && char_b == '!' ) {
                //Case 3.1
                if(a.substring(ind_a2, ind_a1) == (b.substring(ind_b2, ind_b1))) {
                    ind_a2 = ind_a1;
                    ind_b2 = ind_b1;
                }
                //Case 3.2
                else {
                    return a.substring(ind_a2,ind_a1).compareTo(b.substring(ind_b2,ind_b1));
                }                       
            }       
            ind_a1++;
            ind_b1++;
        }


    }

}

当前输出顺序为[2，1 !, 10 !, 100，100！]。我知道它不起作用，因为2的索引少于1！因此它将返回-1。但是，是否有任何方法可以调整代码（或使其变得更好，我将非常感激）以使其正常工作？

（例如，输入[A5，a5，A5！，a5！，！A，！a，A，a，1，!!]

输出应为[！，！A，！a，1，A，a，A5，A5 !, a5！ ]）

Answer 1

public static void main(String... S) {
    List a = Arrays.asList("1!", "10!", "100!", "100", "2");
    Collections.sort(a, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            int oo1 = 0;
            int oo2 = 0;

            if (o1.contains("!")) {
                oo1 = 1;
                o1 = o1.replace("!", "");
            }

            if (o2.contains("!")) {
                oo2 = 1;
                o2 = o2.replace("!", "");
            }

            int result = (Integer.valueOf(o1) - Integer.valueOf(o2));

            return result == 0 ? oo1 - oo2 : result;
        }
    });
    System.out.println(a);

}

根据评论

@Psingh我们不必处理“ !!!!”场景。期望值应为[2，A，1 !, 10 !, 100，100！ ]

public static void main(String... S) {
    List a = Arrays.asList("1!", "1!!", "10!", "100!", "100", "2", "A");
    Collections.sort(a, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            int ooo1 = 0;
            int ooo2 = 0;

            for (char i : o1.toCharArray()) {
                ooo1 += (int) i;
            }
            for (char i : o2.toCharArray()) {
                ooo2 += (int) i;
            }
            return ooo1 - ooo2;
        }
    });
    System.out.println(a);
}

Answer 2

编辑：：添加了前面提到的测试用例，以指出不一致之处。

尝试一下。我仍然不确定这是否满足您的所有输入要求，但可以用于以下测试用例：

input: [A5,a5,A5!,a5!,!A,!a,A,a,1,!]
expected output: [!, !A, !a, 1, A, a, A5, a5, A5!, a5!]

input: [1!, 1!!, 10!, 100!, 100, 2, A]
expected output: [2, A, 1!, 1!!, 10!, 100, 100!]

但是对于此测试用例：

input: [1!, 10!, 100, 100!, 2 , 2!, 22!, 22, 100 , 3]
expected output: [1!, 2, 2!, 3, 22, 22!, 100, 100!]

输出是不同的。在这种情况下，您的期望似乎不一致，因为此示例对元素2和1具有不同的顺序。

只要是这种情况，尝试回答您的问题就没有任何意义。

    Collections.sort(a, new Comparator<String>() {

        @Override
        public int compare(String o1, String o2) {

            int minSize = Math.min(o1.length(), o2.length());
            int index = 0;

            while (index < minSize) {

                char c1 = o1.charAt(index);
                char c2 = o2.charAt(index);

                if (c1 != c2) {

                    if (o1.length() == o2.length()) {
                        return c1 - c2;
                    }

                    if (c1 == '!') {
                        return -1;
                    } else if (c2 == '!') {
                        return 1;
                    }

                    return o1.length() - o2.length();
                }

                index++;
            }

            if (o1.length() == index) {
                if (o2.length() == index) {
                    return 0;
                }

                return -1;
            } else {
                return 1;
            }
        }
    });

Java

2 个答案:

}