Java 排序a"；分类；排列 假设给定一个大小为n的数组，带有排序值 在迭代i中，给出一个新的随机生成值，并将其插入数组的末尾 然后重新调用数组，并丢弃最小值项 在迭代n之后，保留的数组将包含最大值项

例如，在Java语法中，它类似于：

List l = new ArrayList();
l.add(new Integer(2));
l.add(new Integer(3));
l.add(new Integer(6));
l.add(new Integer(9));

Random rand = new Random();
for (int i=0; i < n; i++) {
  l.add(new Integer(rand.nextInt(1000)));
}    
Collections.sort(l);
l.remove(0);

listl=newarraylist（）；
l、 加（新整数（2））；
l、 加（新整数（3））；
l、 加（新整数（6））；
l、 加（新整数（9））；
Random rand=新的Random（）；
对于（int i=0；i

但它似乎效率很低。有更好的算法吗？

对新值使用二进制插入（类似于二进制搜索）。丢弃最小的。应该很快

顺便说一下，这可以作为一种方便的扩展方法来实现：

private static int GetSortedIndex( this IList list, IComparer comparer, object item, int startIndex, int endIndex )
{
  if( startIndex > endIndex )
  {
    return startIndex;
  }
  var midIndex = startIndex + ( endIndex - startIndex ) / 2;
  return comparer.Compare( list[midIndex], item ) < 0 ?
    GetSortedIndex( list, comparer, item, midIndex + 1, endIndex ) :
    GetSortedIndex( list, comparer, item, startIndex, midIndex - 1 );
}

public static void InsertSorted( this IList list, IComparer comparer, object item )
{
  list.Insert( list.GetSortedIndex( comparer, item ), item );
}

private static int GetSortedIndex（此IList列表、IComparer比较器、对象项、int startIndex、int endIndex）
{
如果（开始索引>结束索引）
{
返回startIndex；
}
var midIndex=startIndex+（endIndex-startIndex）/2；
返回comparer.Compare（列表[midIndex]，项）<0？
GetSortedIndex（列表、比较器、项、midIndex+1、endIndex）：
GetSortedIndex（列表、比较器、项、startIndex、midIndex-1）；
}
公共静态void InsertSorted（此IList列表、IComparer比较器、对象项）
{
list.Insert（list.GetSortedIndex（比较器，项目），项目）；
}

Java等价物

public static void main(String[] args)
{
   List l = new ArrayList();
   l.add(new Integer(2));
   l.add(new Integer(3));
   l.add(new Integer(6));
   l.add(new Integer(9));

   Random rand = new Random();
   for (int i=0; i < 10; i++) {
       Integer rnd = new Integer(rand.nextInt(1000));
       int pos = Collections.binarySearch(l,rnd);
       if(pos < 0) pos = ~pos;
       l.add(pos,rnd);
   }    
   System.out.println(l);
}

publicstaticvoidmain（字符串[]args）
{
列表l=新的ArrayList（）；
l、 加（新整数（2））；
l、 加（新整数（3））；
l、 加（新整数（6））；
l、 加（新整数（9））；
Random rand=新的Random（）；
对于（int i=0；i<10；i++）{
整数rnd=新整数（rand.nextInt（1000））；
int pos=Collections.binarySearch（l，rnd）；
如果（pos<0）pos=~pos；
l、 添加（pos、rnd）；
}    
系统输出打印LN（l）；
}

一个非常简单的优化方法是在插入新值之前，将排序数组中的最低值（因此应为第一项）与新值进行比较。如果新值大于此值，请用新值替换元素，然后使用数组。

您可以使用二进制搜索将值插入到排序数组中

使用一个而不是一个

列表

，它将保持顺序，以便最大值始终为。如果使用1.6+您可以使用方法；将返回并删除最高值

NavigableSet<Integer> set = new TreeSet<Integer>();

//... setup data

Integer highest = set.pollLast();

set.add(rand.nextInt(1000));

Integer newHighest = set.pollLast();

NavigableSet集=新树集（）；
//... 设置数据
最高整数=set.pollLast（）；
集合。添加（兰特。耐克斯汀（1000））；
整数newHighest=set.pollLast（）；

使用最小值堆存储数据，每次插入新的随机值后，在O（1）时间内删除最小值

---

在n次迭代后，执行n次extract min’s以获得排序列表。

如果您使用的是ArrayList，则可以使用新数字替换数组中的最后一个数字（如果新数字在排序数组之前更大）

Java

Collections.sort

使用合并排序，在这种情况下，合并排序不是最有效的排序方式。您希望使用二进制搜索来查找插入点，然后将所有后续数字移动1

编辑：仅使用如下数组即可完成此操作：

public static int addDiscard(int[] list, int number)
{
    if (number > list[list.length - 1])
    {
        int index = findInsertionIndex(list, number); // use binary search
        for (int i = list.length - 1; i > index; i--)
        {
            list[i] = list[i - 1];
        }
        list[index] = number;
    }
}

---

我不知道您是否可以更改数据结构，或者需要支持哪些其他操作，但堆更适合您描述的操作。

这将使大小保持在4，并按照我的理解执行您想要的操作

SortedSet<Integer> set = new TreeSet<Integer>();
set.add(2);
set.add(3);
set.add(6);
set.add(9);
Random rand = new Random();
for (int i=0; i < n; i++) {
  int i = rand.nextInt(1000);
  set.remove(set.first());
  set.add(i);
}    

SortedSet set=new TreeSet（）；
增加（2）；
增加（3）；
增加（6）；
增加（9）；
Random rand=新的Random（）；
对于（int i=0；i

我能想到的最快的算法是，如果需要，用新的元素替换最小的元素，并通过与相邻元素重复交换，将新元素推到适当的位置

编辑：代码假定数组按降序排序，因此最后一个元素是最小的

void Insert(int[] array, int newValue)
{
    // If the new value is less than the current smallest, it should be
    // discarded
    if (new_value <= array[array.length-1])
        return;

    array[array.length-1] = newValue;
    for (int i = array.length-1; i > 0; --i)
    {
        if (newValue <= array[i-1])
            break;

        // Swap array[i] with array[i-1]
        array[i] = array[i-1];
        array[i-1] = newValue;
    }
}

void插入（int[]数组，int newValue）
{
//如果新值小于当前最小值，则应为
//丢弃
if（新的_值0；--i）
{
如果（新值


伪代码将一组新项目N插入到大小为S的排序列表a中，然后丢弃最小的项目。使用Collections.binarySearch（）查找插入点。[阅读注释如果列表不支持RandomAccess，则会影响性能。ArrayList支持RandomAccess。]

listl=newarraylist（）；
l、 加（新整数（2））；
l、 加（新整数（3））；
l、 加（新整数（6））；
l、 加（新整数（9））；
l、 确保容量（l.尺寸（）+n）；
Random rand=新的Random（）；
对于（int i=0；i

但是，您确定只想丢弃1个项目吗？或者您的意思是将一组新项目N插入大小为S的排序列表a中，并只保留最大的项目。在这种情况下，请跟踪最小值：

int min = l.get(0);
l.ensureCapacity(l.size()+n);

Random rand = new Random();
for (int i=0; i < n; i++) {
  final Integer newInt = Integer.rand.nextInt(1000);
  if (newInt > min) {
    int insertPoint = Collections.binarySearch(l, newInt);
    if (insertPoint < 0)  insertPoint = -(insertPoint + 1);
    l.add(insertPoint, newInt);
  }
}

int min=l.get（0）；
l、 确保容量（l.尺寸（）+n）；
Random rand=新的Random（）；
对于（int i=0；imin）{
int insertPoint=Collections.binarySearch（l，newInt）；
如果（insertPoint<0）insertPoint=-（insertPoint+1）；
l、 添加（插入点，newInt）；
}
}

但是，如果N较大，则最好将N单独排序到一个已排序数组中，丢弃N（0）或A（0）中较小的一个，然后将两个已排序数组合并在一起[留给读者练习]

如果最终使用实际数组，则
int min = l.get(0);
l.ensureCapacity(l.size()+n);

Random rand = new Random();
for (int i=0; i < n; i++) {
  final Integer newInt = Integer.rand.nextInt(1000);
  if (newInt > min) {
    int insertPoint = Collections.binarySearch(l, newInt);
    if (insertPoint < 0)  insertPoint = -(insertPoint + 1);
    l.add(insertPoint, newInt);
  }
}

public static <T extends Comparable<T>> 
        void insertAndRemoveSmallest(T[] array, T t) {
    int pos = Arrays.binarySearch(array, t);
    if (pos < 0) pos = ~pos;
    // this is the smallest entry so no need to add it and remove it.
    if (pos == 0) return;
    pos--;
    // move all the entries down one.
    if (pos > 0) System.arraycopy(array, 1, array, 0, pos);
    array[pos] = t;
}

public static void main(String... args) {
    Integer[] ints = {2, 3, 7, 6, 9};
    System.out.println("Starting with " + Arrays.toString(ints));
    for (int i : new int[]{5, 1, 10, 8, 8}) {
        insertAndRemoveSmallest(ints, i);
        System.out.println("After adding " + i + ": " + Arrays.toString(ints));
    }
}

Starting with [2, 3, 7, 6, 9]
After adding 5: [3, 5, 7, 6, 9]
After adding 1: [3, 5, 7, 6, 9]
After adding 10: [5, 7, 6, 9, 10]
After adding 8: [7, 6, 8, 9, 10]
After adding 8: [6, 8, 8, 9, 10]