java - 有没有更简单的方法来递归地编写此代码？

Question

这个问题不太可能对任何 future 的访客有帮助；它只与一个较小的地理区域、一个特定的时间点或一个非常狭窄的情况相关，通常不适用于全世界的互联网受众。如需帮助使此问题更广泛适用， visit the help center 。

已关闭 11 年前。

我的目标是编写一个方法，该方法接受 2 个字符串数组，并根据每个元素的长度对数组中的元素进行排序。通过使用合并排序???

这是我的代码，但我希望它更加简洁，而且我不知道该代码是否是递归的。

import java.util.Arrays;
import java.util.Comparator;

public class Test {

    private static Comparator<String> COMP = new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            if(o1.length() < o2.length()) {
                return -1;
            }
            if(o1.length() > o2.length()) {
                return 1;
            }
            return o1.compareToIgnoreCase(o2);
        }
    };

    public static String[] mergeUnsorted(String[] arr1, String[] arr2) {
        arr1 = sort(arr1);
        arr2 = sort(arr2);

        return merge(arr1, arr2);
    }

    private static String[] sort(String[] arr) {
        if(arr.length <= 1)
            return arr;

        String[] left = Arrays.copyOfRange(arr, 0, arr.length/2);
        String[] right = Arrays.copyOfRange(arr, arr.length/2, arr.length);

        left = sort(left);
        right = sort(right);

        String[] combined = merge(left, right);

        return combined;
    }

    private static String[] merge(String[] arr1, String[] arr2) {
        String[] combined = new String[arr1.length + arr2.length];

        int a = 0, b = 0, i = 0;

        while(a < arr1.length || b < arr2.length) {
            int compare = 0;
            if(a >= arr1.length) {
                compare = 1;
            } else if(b >= arr2.length) {
                compare = -1;
            } else {
                compare = COMP.compare(arr1[a], arr2[b]);
            }

            if(compare < 0) {
                combined[i] = arr1[a];
                i++;
                a++;
            } else if(compare > 0) {
                combined[i] = arr2[b];
                i++;
                b++;
            } else {
                combined[i] = arr1[a];
                i++;
                a++;
                combined[i] = arr2[b];
                i++;
                b++;
            }
        }

        return combined;
    }

    public static void main(String[] args) {
        String[] arr1 = new String[] { "abc", "a", "A", "bA", "Ba" };
        String[] arr2 = new String[] { "def", "d", "D", "fG", "Fg", "abcde", "B" };

        System.out.println(Arrays.toString(mergeUnsorted(arr1, arr2)));
    }
}

Answer 1

sort 静态方法调用自身，所以，是的，它是递归的。

就其功能、使用的语言以及所达到的效率而言，它并不是那么糟糕的代码。如果你想要更短，为什么不使用 Comparator 和 Arrays.sort？

(您可以通过在数组访问中后递增变量来节省丑陋的合并代码中的几行)