Question

所以我有一个对象列表。所有相同的类型。我们称之为Foo。 Foo有一个属性＆＃34;值＆＃34;而且我想按这个价值排序。我用Java实现了算法。它是通用的，我提供了两个例子。一个使用整数，另一个使用枚举常量作为值的类型。

算法简单地迭代所有可能的值，然后迭代每个这样的值的输入列表。具有相同值的所有元素都将添加到结果列表中。就是这样。

如果有11个值，那么它将迭代列表11次。因此时间复杂度为O（11 * n）。但是11是一个常数，所以它实际上是O（n），这对于排序算法来说非常好。即使可能有数十亿的价值，它仍然是O（n）。假设这是正确的吗？

我实际上在我必须处理的一些代码中找到了类似的东西。我只花了一些时间来弄清楚代码的作用，因为我不希望任何人真正实现排序算法。代码是由一个不知道Java允许您按Collections.sort(myList, Comparator.comparing(Foo::getValue))排序的人编写的。

起初我认为这是一种排序列表的可怕方式，但后来我意识到它实际上非常快，甚至稳定。但它不是到位。我想知道该算法的名称是什么。

在对实际数据进行测试时，常见算法（如快速排序）的性能可能仍然要好得多。所以我想知道这个是否曾被使用过。

以下是代码：

import java.util.*;
import java.util.function.Function;
import java.util.stream.*;

public class SortAlgo {
  /**
   * Sorts a list. The sort is stable. 
   * The input won't be changed. A new list is returned instead.
   * 
   * @param list
   *          The list to be sorted.
   * @param values
   *          The possible values of the field used for the sorting.
   * @param get
   *          A function to get the value.
   * @return A new, sorted list.
   */
  public static <T, V> List<T> sort(final List<T> list, final List<V> values,
      final Function<T, V> get) {
    final List<T> result = new ArrayList<>(list.size());
    for (final V v : values)
      for (final T t : list)
        if (get.apply(t) == v)
          result.add(t);
    assert result.size() == list.size();
    return result;
  }

  static class Foo1 {
    public static final int MIN_VALUE = 0;
    public static final int MAX_VALUE = 10;
    final private int value;

    public Foo1(final int value) {
      this.value = value;
    }

    public int getValue() {
      return this.value;
    }

    @Override
    public String toString() {
      return Integer.toString(this.value);
    }
  }

  static class Foo2 {
    public static enum Value {
      A, B, C, D, E;
    }

    final private Value value;

    public Foo2(final Value value) {
      this.value = value;
    }

    public Value getValue() {
      return this.value;
    }

    @Override
    public String toString() {
      return this.value.name();
    }
  }

  public static void main(final String[] args) {
    final List<Foo1> list1 = new ArrayList<>();
    final Random rng = new Random();
    for (int i = 0; i < 100; i++)
      list1.add(new Foo1(rng.nextInt(Foo1.MAX_VALUE + 1)));

    final List<Integer> values1 = IntStream.rangeClosed(Foo1.MIN_VALUE, Foo1.MAX_VALUE).boxed()
        .collect(Collectors.toList());
    final List<Foo1> sorted1 = sort(list1, values1, Foo1::getValue);

    System.out.println(sorted1);

    // -------------------------

    final List<Foo2> list2 = new ArrayList<>();
    final Foo2.Value[] enums = Foo2.Value.values();
    for (int i = 0; i < 100; i++)
      list2.add(new Foo2(enums[rng.nextInt(enums.length)]));

    final List<Foo2.Value> values2 = Arrays.asList(enums);
    final List<Foo2> sorted2 = sort(list2, values2, Foo2::getValue);

    System.out.println(sorted2);

  }

}

Answer 1

它本质上是一个counting sort，它是O（n），但有一个额外的循环，而不是将值存储在一个数组中，只循环一次。

这个排序算法的名称和时间复杂度是什么？

1 个答案: