zoukankan      html  css  js  c++  java
  • Collections sort() 合并排序

    Collections 的sort方法使用的是合并排序算法,使用时注意list中的元素需要实现Comparable接口。

     这里有个简单的例子:

      1 public int compareTo(Object obj) {

     2         if (obj instanceof TestObject) {
     3             TestObject to = (TestObject) obj;
     4             if (this.getLength() > to.getLength()) {
     5                 return 1;
     6             } else if (this.getLength() == to.getLength()) {
     7                 return 0;
     8             } else {
     9                 return -1;
    10             }
    11         } else {
    12             throw new ClassCastException();
    13         }
    14     }

    下面是源码: 

     1     /**
     2      * Sorts the specified list into ascending order, according to the
     3      * <i>natural ordering</i> of its elements.  All elements in the list must
     4      * implement the <tt>Comparable</tt> interface.  Furthermore, all elements
     5      * in the list must be <i>mutually comparable</i> (that is,
     6      * <tt>e1.compareTo(e2)</tt> must not throw a <tt>ClassCastException</tt>
     7      * for any elements <tt>e1</tt> and <tt>e2</tt> in the list).<p>
     8      *
     9      * This sort is guaranteed to be <i>stable</i>:  equal elements will
    10      * not be reordered as a result of the sort.<p>
    11      *
    12      * The specified list must be modifiable, but need not be resizable.<p>
    13      *
    14      * The sorting algorithm is a modified mergesort (in which the merge is
    15      * omitted if the highest element in the low sublist is less than the
    16      * lowest element in the high sublist).  This algorithm offers guaranteed
    17      * n log(n) performance.
    18      *
    19      * This implementation dumps the specified list into an array, sorts
    20      * the array, and iterates over the list resetting each element
    21      * from the corresponding position in the array.  This avoids the
    22      * n<sup>2</sup> log(n) performance that would result from attempting
    23      * to sort a linked list in place.
    24      *
    25      * @param  list the list to be sorted.
    26      * @throws ClassCastException if the list contains elements that are not
    27      *           <i>mutually comparable</i> (for example, strings and integers).
    28      * @throws UnsupportedOperationException if the specified list's
    29      *           list-iterator does not support the <tt>set</tt> operation.
    30      * @see Comparable
    31      */
    32     public static <extends Comparable<? super T>> void sort(List<T> list) {
    33     Object[] a = list.toArray();
    34     Arrays.sort(a);
    35     ListIterator<T> i = list.listIterator();
    36     for (int j=0; j<a.length; j++) {
    37         i.next();
    38         i.set((T)a[j]);
    39     }
    40     }
  • 相关阅读:
    三次请求(读-改-读)引出nibernate 一级缓存
    算法竞赛入门经典第一、二章摘记
    uva 10905 Children's Game
    uva 11205 The broken pedometer
    uva 10160 Servicing stations
    uva 208 Firetruck
    uva 167 The Sultan's Successors
    zoj 1016 Parencodings
    uva 307 Sticks
    uva 216 Getting in Line
  • 原文地址:https://www.cnblogs.com/kelin1314/p/1840674.html
Copyright © 2011-2022 走看看