如何为一对泛型实现快速排序方法？

Question

所以我有一个类对，它存储两个变量：键和值。我还有一个 MyArrayList 类，它扩展了 ArrayList 并包含一个快速排序方法，该方法将对插入的整数数组列表进行排序。我的问题是如何使这种快速排序方法与对而不是数组列表中的单个值一起使用。 对类：

class Pair<K extends Comparable<K>, V extends Comparable<V>> {
public K key;
public V value;

// Default Constructor
public Pair(){
}

// Parametrized Constructor
public Pair(K key, V value){
this.key = key;
this.value = value;
}

@Override
public String toString() {
return "Pair {" + this.key + ", " + this.value + "}";
}

// Setter Functions:
public void setKey(K key){
this.key = key;
}

public void setValue(V value){
this.value = value;
}

// Getter Functions:
public K getKey(){
return key;
}

public V getValue(){
return value;
}

}

MyArrayList 类：

public class MyArrayList<K extends Comparable<K>, V extends Comparable<V>> extends ArrayList<Pair<K,V>>{
     MyArrayList<Integer ,Integer> array = new MyArrayList<Integer,Integer>();

     public static void main(String[] args){
     MyArrayList<String,Integer> array = new MyArrayList<String,Integer>();
    
    }   
 
  public String String(){
      ArrayList<String> copy = (ArrayList<String>)array.clone();
      return copy.toString();
    }
    
  public ArrayList QuickSort(ArrayList<Integer> arr){
      
      if (arr.size()< 1) return arr;
      
    ArrayList<Integer> sorted = new ArrayList<Integer>();
    ArrayList<Integer> lesser = new ArrayList<Integer>();
    ArrayList<Integer> greater = new ArrayList<Integer>();
    
    Integer pivot = arr.get(arr.size()-1); 
    
    for (int i = 0; i < array.size()-1; i++)
    {
        if (arr.get(i) < pivot)
            lesser.add(arr.get(i));    
        else
            greater.add(arr.get(i));   
    }

    lesser = QuickSort(lesser);
    greater = QuickSort(greater);

    lesser.add(pivot);
    lesser.addAll(greater);
    sorted = lesser;

    return sorted;
      
    }
    
    
    
}

Answer 1

好吧，你只是不得不这样做;）。您首先必须决定比较您的两个Pairs 意味着什么。我选择比较他们的钥匙。相反，比较它们的值或您想要设计的任何其他类型的比较将是一个简单的更改。一旦决定，您只需在 Pair 类中覆盖 compareTo 即可实施该决定。

您必须更改您的排序代码以使用您的Pair<K, V> 而不是Integers。真正最实质性的变化是使用compareTo 方法而不是标准运算符。我进行了转换，只是为了好玩，同时还进行了一些其他清理工作：

import java.util.ArrayList;

class Pair<K extends Comparable<K>, V extends Comparable<V>> {
    public K key;
    public V value;

    // Parametrized Constructor
    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public String toString() {
        return "Pair {" + this.key + ", " + this.value + "}";
    }

    // Setter Functions:
    public void setKey(K key) {
        this.key = key;
    }

    public void setValue(V value) {
        this.value = value;
    }

    // Getter Functions:
    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }

    public int compareTo(Pair<K, V> o) {
        return key.compareTo(o.getKey());
    }
}

class MyArrayList<K extends Comparable<K>, V extends Comparable<V>> extends ArrayList<Pair<K, V>> {

    private ArrayList<Pair<K, V>> quicksort(ArrayList<Pair<K, V>> arr) {

        if (arr.size() < 2) return arr;

        ArrayList<Pair<K, V>> lesser = new ArrayList<>();
        ArrayList<Pair<K, V>> greater = new ArrayList<>();

        Pair<K, V> pivot = arr.get(arr.size() - 1);

        for (int i = 0; i < arr.size() - 1; i++) {
            if (arr.get(i).compareTo(pivot) < 0)
                lesser.add(arr.get(i));
            else
                greater.add(arr.get(i));
        }

        lesser = quicksort(lesser);
        greater = quicksort(greater);

        lesser.add(pivot);
        lesser.addAll(greater);

        return lesser;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (Pair<K, V> p : this) {
            if (sb.length() > 1)
                sb.append(',');
            sb.append('{').append(p.key).append(':').append(p.value).append('}');
        }
        sb.append(']');
        return sb.toString();
    }


    public void quicksort() {
        ArrayList<Pair<K, V>> r = quicksort(this);
        for (int i = 0 ; i < r.size() ; i++)
            set(i, r.get(i));
    }
}

public class Test {

    public static void main(String[] args) {
        MyArrayList<Integer, String> pairs = new MyArrayList<>();
        pairs.add(new Pair<>(7, "foo"));
        pairs.add(new Pair<>(23, "blah"));
        pairs.add(new Pair<>(24, "xxx"));
        pairs.add(new Pair<>(14, "blech"));
        pairs.add(new Pair<>(3, "abc"));
        pairs.add(new Pair<>(-24, "wow"));

        System.out.println(pairs);
        pairs.quicksort();
        System.out.println(pairs);
    }
}

结果：

[{7:foo},{23:blah},{24:xxx},{14:blech},{3:abc},{-24:wow}]
[{-24:wow},{3:abc},{7:foo},{14:blech},{23:blah},{24:xxx}]