Java 排序三个值列表的最快算法是什么？

Arrays.sort（）；这不是解决办法。我知道有一种更快的算法实现方法

电流输出：顺序：中、右、左、中、左、

有序输出：有序：左、左、中、中、右

---

值范围是固定的

当您有一个小的、固定的值范围时，您可以使用。该算法包括计算每种类型的项目数量，然后按顺序发出每个项目的数量。对于较大的数字，如果不可能保持每个可能值的计数，则可以在每个数字上重复此过程。对于只有一个数字要计数的特殊情况（如这里的情况），该算法也称为a（从技术上讲，基数排序是对被排序的值的各个数字或桶重复应用计数排序）

给你一些代码：

public class Sort {

    enum Sides {
        left, middle, right
    };

    public static void main(String[] param) {
        Sides[] list = { Sides.middle, Sides.right, Sides.left, Sides.middle, Sides.left };

        order(list);
        System.out.print("Ordered: ");
        for (Sides side : list) {
            System.out.print(side.toString() + ", ");
        }
    }

    public static void order(Sides[] sides) {
        //toDo
    }
}

这种编写自定义构造函数并向枚举类添加方法的机制在其他场景中很方便，但显然不应用于复制已内置的功能。

您需要一些n log（n）排序算法。可能是最快的。还有一个Quicksort的Java示例实现

---

也就是说，对于这个问题来说，这可能有点过头了。

另一个不涉及更改枚举的选项（这实际上是一个：

公共类排序{
枚举边{
左、中、右
}
公共静态void main（字符串[]参数）{
Sides[]list={Sides.middle，Sides.right，Sides.left，Sides.middle，Sides.left}；
订单（清单）；
系统输出打印（“订购：”）；
用于（侧面：列表）{
System.out.print（side.toString（）+“，”）；
}
}
公共静态无效令（方[]方）{
Sides[]可能值=Sides.values（）；
int[]计数=新的int[possibleValues.length]；
用于（侧面：侧面）{
计数[side.ordinal（）]+；
}
int i=0；
对于（int j=0；j

如果列表很小（~20个元素或更小），只需使用。它将比快速排序更快（尽管我相信合并排序是Java中使用的标准排序算法）

但是，这将要求您重载小于运算符。因为这是Java，所以您只需编写一个LessThan方法即可

---

希望这有帮助

sort（）是一种O（n logn）算法。然而，正如OP所说，在这种特殊情况下，实现更快的排序是可能的。所有排序都是算法的，所以说“有一种更快的算法实现方式”是毫无意义的。当你说“三种类型的订单列表”时，你的意思似乎是3个值，因为它们都有相同的类型（

边

）。@Andreas我认为他的术语有道理。。。他要求的解决方案具有更好的渐进运行时复杂性（因此“算法上更快”），而不是在基准测试中表现更好的解决方案（对于较小的N值，使用优化良好的数组。sort（）可能比实现较差的基数排序快得多）@MichaelAaronSafyan如果OP说“我知道还有另一种算法更快”，那么这个术语是有道理的，但从措辞上看，OP是在暗示

Arrays.sort（）

不是一种算法实现，事实上，这就是我的观点。@Andreas的标题现在应该更好了。这是一个简单的线性解决方案。您不能从枚举构造函数访问静态成员。您不需要在

端使用这些
getTypeCount（）
=
values（）.length
，
intValue（）
=
ordinal（）
，
fromValue（int）
=
values（）[int]
@Andreas cool，我没有意识到这些是自动生成的。
 enum Side {
    LEFT,
    MIDDLE,
    RIGHT
 }

 public static Side[] sort(Side[] sides) {
    Side[] values = Side.values();
    int valueCount = values.length;
    int[] counts = new int[valueCount];
    Arrays.fill(counts, 0);
    for (Side side : sides) {
       counts[side.ordinal()]++;
    }
    Side[] result = new Side[sides.length];
    int resultIndex = 0;
    for (int countIndex = 0; countIndex < counts.length; countIndex++) {
      int count = counts[countIndex];
      Side side = values[countIndex];
      for (int i = 0; i < count; i++) {
        result[resultIndex] = side;
        resultIndex++;
      }
    }
    return result;
 }

enum Side {
  LEFT,
  MIDDLE,
  RIGHT;

  private static int typeCount;
  private static Map<Integer, Side> valueToSide = new HashMap<>();
  private int value;

  private Side() {
    value = typeCount;
    valueToSide.put(value, this);
    typeCount++;
  }

  public static int getTypeCount() {
    return typeCount;
  }

  public static Side fromValue(int value) {
    return valueToSide.get(value);
  }

  public int intValue() {
    return value;
  }
}

public class Sort {

    enum Sides {
        left, middle, right
    }

    public static void main(String[] param) {
        Sides[] list = {Sides.middle, Sides.right, Sides.left, Sides.middle, Sides.left};

        order(list);
        System.out.print("Ordered: ");
        for (Sides side : list) {
            System.out.print(side.toString() + ", ");
        }
    }

    public static void order(Sides[] sides) {
        Sides[] possibleValues = Sides.values();

        int[] counts = new int[possibleValues.length];
        for (Sides side : sides) {
            counts[side.ordinal()]++;
        }

        int i=0;
        for (int j = 0; j < counts.length; j++)
            for (int k = 0; k < counts[j]; k++)
                sides[i++] = possibleValues[j];

    }
}