Question

问题是根据字符串的长度对字符串数组进行排序。

例如

input = {"cat", "star", "act", "gid", "arts", "dog", "rats"}  
output = {"cat", "act", "gid", "dog", "star", "arts", "rats"}

我使用插入排序（使用字符串的长度而不是字符串本身）来完成它。我的问题是：有更好的方法吗？

我想到的另一种选择是 - 使用TreeMap存储每个字符串及其长度作为值（假设字符串在给定数组中是唯一的）。然后根据其值对其进行排序。运行时间为O(nlogn)，空间复杂度为O(n)。你认为这是一种更好的方法吗？

编辑：很抱歉没有提及此问题 - 我想在不使用Arrays.sort()或自定义比较器的情况下执行此操作。

插入排序的代码示例：

public static String[] insertionSort(String[] arr) {
    for(int i=1;i<arr.length;i++) {
        int j = 0;
        for(;j<i;j++) {
            if(arr[j].length() > arr[j+1].length()) {
                String temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    return arr;
}

Answer 1

试试这个。

您的输入

String[] input = {"cat", "star", "act", "gid", "arts", "dog", "rats"};

你的比较者

class SampleComparator implements Comparator<String> {
    @Override
    public int compare(String o1, String o2) {
        return new Integer(o1.length()).compareTo(o2.length());
   }
}

您的排序

Collections.sort(in, new SampleComparator());

您的输出

output = {"cat", "act", "gid", "dog", "star", "arts", "rats"}

Answer 2

    String[] str={"umbrella","apple", "baby", "cat","rat","obnoxious"};
    Arrays.sort(str, new Comparator<String>() {

        @Override
        public int compare(String o1, String o2) {
            return o1.length()-o2.length();
        }
    });

Answer 3

有很多更好的方法可以做到这一点。对于插入排序，我们说的是O（n ^ 2）。一个更好的排序算法可能是mergesort（更好的最坏情况）或quicksort（平均更好）。由于这是基于长度的排序，因此可以采用多种方法。您将不得不在某个时刻计算每个字符串的长度。你可以做的是创建一个int数组，它对应于相同索引处的单词长度。然后你可以在整数上运行mergesort或quicksort，并确保同时翻转字符串。最终结果将是一个非递减的整数数组和一个非递减的字符串数组。

Answer 4

如果您可以使用Collection（例如，ArrayList在您的情况下会很棒），您可以使用Collections.sort为您完成工作。它快速而干净。请参阅：java.util.List

您需要一个自定义比较器。

public class StringComparator implements Comparator<String>
{
    @Override
    public int compare(String s1, String s2) 
    {
        return s1.length()-s2.length();
    }
}

Answer 5

您可以使用以下比较器：

public static class OrderStringByLength implements Comparator<String> {
    @Override
    public int compare(String s1, String s2) {
        int c = s1.length() - s2.length();
        return (c != 0) ? c : s1.compareTo(s2);
    }
}

然后您可以按如下方式对数组进行排序：

Arrays.sort(input, new OrderStringByLength());

Answer 6

public class SortArrayOfStringOnLength {

public static void main(String[] args) {
    String[] strArray = new String[] { "cat", "star", "act", "gid", "arts",
            "dog", "rats" };

    printArray(strArray);

    String[] outputArray = getSortedArray(strArray);
    printArray(outputArray);

}

private static String[] getSortedArray(String[] strArray) {

    Map map = new TreeMap();
    for (int i = 0; i < strArray.length; i++) {
        String str = strArray[i];
        if (map.containsKey(str.length())) {
            List list = (List) map.get(str.length());
            list.add(str);
            map.put(str.length(), list);
        } else {
            List list = new ArrayList();
            list.add(str);
            map.put(str.length(), list);
        }
    }

    Set set = map.keySet();

    Iterator itr = set.iterator();
    int outArrayIndex = 0;
    String[] outputArray = new String[strArray.length];
    while (itr.hasNext()) {

        Integer intValue = (Integer) itr.next();
        List list = (List) map.get(intValue);
        for (int i = 0; i < list.size(); i++) {
            outputArray[outArrayIndex] = (String) list.get(i);
            outArrayIndex++;
        }
    }

    return outputArray;
}

private static void printArray(String[] strArray) {

    System.out.println("*****************");
    for (int i = 0; i < strArray.length; i++) {
        System.out.println(strArray[i]);
    }

}

}

Answer 7

            both
2016-03-20    NA
2016-03-21 FALSE
2016-03-22 FALSE
2016-03-23  TRUE
2016-03-24 FALSE
2016-03-25 FALSE
2016-03-26  TRUE

Answer 8

问题：根据字符串长度对字符串数组进行排序。我们可以使用Java 8中的流来做到这一点

public class SortStringsAccordingToLength {

    public static void main(String[] args) {
        List<String> sampleStrings = Arrays.asList("Protijayi", "Gina", "Gini", "Soudipta");

        System.out.println(lengthSortUsingSorted1(sampleStrings));

        System.out.println(lengthSortUsingSorted2(sampleStrings));
        System.out.println(lengthSortUsingSorted3(sampleStrings));
        System.out.println(lengthSortUsingSorted4(sampleStrings));
    }

    private static List<String> lengthSortUsingSorted4(List<String> list) {

        list.sort((a, b) -> Long.compare(a.length(), b.length()));
        System.out.println(list);

        return list;
    }

    private static List<String> lengthSortUsingSorted3(List<String> sampleStrings) {
        List<String> list1 = sampleStrings.stream()
                .sorted(Comparator.comparingLong(String::length).thenComparing(Comparator.naturalOrder()))
                .collect(Collectors.toList());
        return list1;
    }

    private static List<String> lengthSortUsingSorted2(List<String> sampleStrings) {
        List<String> list1 = sampleStrings.stream().sorted(Comparator.comparingInt(String::length))
                .collect(Collectors.toList());
        return list1;
    }

    public static List<String> lengthSortUsingSorted1(List<String> sampleStrings) {
        List<String> list1 = sampleStrings.stream().sorted((s1, s2) -> s1.length() - s2.length())
                .collect(Collectors.toList());
        return list1;
    }

}

根据长度对字符串数组进行排序

8 个答案: