Java 一般arraylist bubblesort问题

我知道有内置的例程，但作为一名学习者，我想使用自己的设备进行排序，因为排序是老生常谈，我决定尝试制作自己的通用排序例程，如果我知道它们在Java中是如何工作的，我可以用它来处理数字或字符串，甚至日期

这就是我所拥有的，在用一个错误交换另一个错误之前，我只有两个地方的错误（用“**”标记括起来），需要找出如何进行比较

package sort;
import java.util.ArrayList;

public  abstract class Sort<E> implements Comparable<E> {

   public void swap(ArrayList<E> a, int i, int j) {
    E c = a.get(i);
    a.set(i,a.get(j));// = a[j];
    a.set(j, c);
  }

  public void bubbleSort(ArrayList<E> a) {
    boolean inOrder = false;
    while (!inOrder) {
      inOrder = true;
      for (int i = 1; i < a.size(); i++) {
        **if( a.get(i - 1).compareTo(a.get(i)) > 0 )** {
//cannot find symbol: method compareTo(E); location: class Object
//where E is a type-variable: E extends Object declared in class Sort                 
      inOrder = false;
          swap(a, i, i - 1);
        } 
      }
    }
  }

  public static void main(String args[]) //hadda lose 'static' for 'setLayout' to work
  {
    ArrayList<Integer> ary = new ArrayList<>();
    ary.add(2); ary.add(4); ary.add(7); ary.add(3);
    **bubbleSort(ary)**;
//method bubbleSort in class Sort<E> cannot be applied to given types; 
//required: ArrayList<E>
//found: ArrayList<Integer>
//reason: actual argument ArrayList<Integer> cannot be converted to ArrayList<E> 
//by method invocation conversion where E is a type-variable:
//E extends Object declared in class Sort
    for (int i = 0; i < ary.size(); i++) {
      System.out.println(ary.get(i));
    }
  }

  @Override
  public int compareTo(E o) {
    **return 0;** // fixing errors above may help this fall into place
  }
}

包裹分拣；
导入java.util.ArrayList；
公共抽象类排序实现了可比性{
公共无效掉期（ArrayList a、int i、int j）{
E c=a.get（i）；
a、 集合（i，a.get（j））；//=a[j]；
a、 set（j，c）；
}
public void bubbleSort（ArrayList a）{
布尔顺序=假；
而（！顺序）{
顺序=真；
对于（int i=1；i0相比*{
//找不到符号：方法compareTo（E）；位置：类对象
//其中E是一个类型变量：E扩展类Sort中声明的对象
顺序=假；
互换（a、i、i-1）；
} 
}
}
}
publicstaticvoidmain（字符串args[]）//hadda失去“static”使“setLayout”工作
{
ArrayList ary=新的ArrayList（）；
第二项增补；第四项增补；第七项增补；第三项增补；
**气泡运动（ary）**；
//类排序中的方法bubbleSort无法应用于给定类型；
//必需：ArrayList
//发现：ArrayList
//原因：实际参数ArrayList无法转换为ArrayList
//按方法调用转换，其中E是类型变量：
//扩展类排序中声明的对象
对于（int i=0；i

我试着去学习那些我觉得已经准备好的东西，却发现我还没有完全准备好；关上，不抽雪茄。

这个：

public  abstract class Sort<E> implements Comparable<E> {

这意味着

E

必须是其实例可以相互比较的类型

---

编辑后添加：实际上，正如SLaks-together所指出的那样，

Sort

没有真正的理由是泛型的；您只需要

bubbleSort

方法是泛型的。此外，正如MadProgrammer所暗示的那样，

Sort

应该是非

抽象的

（因此您可以直接实例化它），或者

bubbleSort

应该是

静态的

（因此可以在不实例化

Sort

实例的情况下调用它），或者两者兼而有之。例如：

public class Sort {
    private static <E> void swap(ArrayList<E> a, int i, int j) {
        ...
    }

    private static <E extends Comparable<E>> void bubbleSort(ArrayList<E> a) {
        ...
    }

    ...
}

公共类排序{
专用静态无效交换（ArrayList a、int i、int j）{
...
}
私有静态void bubbleSort（ArrayList a）{
...
}
...
}

---

更好的是，

Sort

可以是一个带有

Sort

方法的接口，

BubbleSort.Sort（…）

只是它的一个实现（而不是给

Sort

一个特定的

BubbleSort

方法）。

在接受SLaks的建议并对泛型更加熟悉之后（昨天制作了通用堆栈和队列类），今天我使用了ruakh的大纲（但必须在“bubblesort”行中将

private

更改为

public

），这使得主要将

main

更改为正常的（现在可以归结为一个做一些有用的事情的行

Sort.bubblesort（ary）；

）这很有效，但我有两个迫切的问题：

（1） 在这行中，第一个

的确切含义是什么

private static <E> void swap(ArrayList<E> a, int i, int j) {

私有静态无效交换（ArrayList a、int i、int j）{

（2） 类似地，

的情况如下：

private static <E extends Comparable<E>> void bubbleSort(ArrayList<E> a) {

private静态void bubbleSort（ArrayList a）{

回答我自己的问题，“现在，为什么我没有想到这些？”…“为什么我会想到它们？”

编辑：“参数化”或“泛型”方法与参数化/泛型类型一样合法，为什么不合法

但我仍然不知道为什么，“显然合法”或“不合法”，我会想到任何一个“把戏”

---

编辑：一个词：体验

如果可以的话，我想发表一点评论

学习BubbleSort是学习如何在Java中使用数据结构的好方法。我同意其他人的观点，在现实世界中，你永远不会使用BubbleSort，因为它提供了除“StoogeSort”之外的所有排序算法中最差的性能

不过，作为一名新学员，如果练习能教会您如何使用和应用泛型类型参数、使用控制流语句（例如for循环）等重要事项，那么练习还是有价值的，甚至做异常处理。不要听反对者的话。Bubblesort的主要优点是算法简单

在我看来，更简单的排序算法是“延迟替换排序”，也称为“选择排序”。延迟替换排序与BubbleSort（O（n^2））具有相同的时间复杂度但与BubbleSort不同的是，选择排序仍在某些应用程序中使用。它作为子算法合并到一些优化排序算法中，并且由于它最大限度地减少了对集合排序所需的交换次数，因此在执行交换的成本很高的情况下，仍然使用选择排序

延迟替换排序的伪代码如下所示，在我看来，它甚至比BubbleSort更简单：

Begin DELAYEDSORT
 For ITEM=1 to maximum number of items in list-1
    LOWEST=ITEM
    For N=ITEM+1 to maximum number of items in list
       Is entry at position N lower than entry at position LOWEST?
          If so, LOWEST=N
    Next N
    Is ITEM different from LOWEST
       If so, swap entry at LOWEST with entry in ITEM
 Next ITEM
End DELAYEDSORT

---

延迟替换排序比BubbleSort快50%，但仍然不应用于对非常大的集合进行排序。

我可以建议，作为学习者，您学习的排序算法比BubbleSort更好吗？此外，如果

BubbleSort（）

是一种实例方法，您可能需要

新排序（）。BubbleSort（ary）；

如果它是一个静态方法，您需要显式地在方法本身上传递类型参数，方法是将该方法声明为

publicstaticbubblesort（arraylista）{…}

，而不是将

Begin DELAYEDSORT
 For ITEM=1 to maximum number of items in list-1
    LOWEST=ITEM
    For N=ITEM+1 to maximum number of items in list
       Is entry at position N lower than entry at position LOWEST?
          If so, LOWEST=N
    Next N
    Is ITEM different from LOWEST
       If so, swap entry at LOWEST with entry in ITEM
 Next ITEM
End DELAYEDSORT