当递归不是一个选项时合并两个排序列表 - Java

Question

我完全被难住了。我已经在解决方案的示例上查找了示例，并且没有像这样的结构。

目标是以从小到大的排序方式组合两个链表。

问题是它必须使用由已创建列表类的对象调用的方法来完成，该对象接受列表类的另一个对象的列表。

编辑：我假设由于方法签名的形式而无法使用递归。如果不是这样，请纠正我。

即。

 list2.mergeSort(list1.getList()); // getList() is a method that returns the list of 
                                   // that object   

签名看起来像

 public List<Integer> mergeSort(List<Integer> otherList)

在组合列表 1 和另一个列表 2 后，您会将生成的合并列表存储在列表 1 中，并由 mergeSort() 方法返回。

如果另一种形式比我选择的列表形式更好，我应该补充一点，列表可以是一个数组或整数、ArrayList 或其他一些列表或数组形式。

可能的解决方案？

 public List<Integer> mergeSort(List<Integer> otherList){

    List<Integer> temp = new LinkedList<Integer>();

    for(int x = 0; x<list.size(); x++){
        if(list.get(x) < otherList.get(x))
            temp.add(list.get(x));
        else
            temp.add(otherList.get(x));
    }

    list = temp;

    return list;
}

Answer 1

简单（推荐用于实际项目）方式：

public MyList<E> mergeSort(Collection<? extends E> list) {
    this.addAll(list);
    Collections.sort(this);
    return this;
}

更详细的方式：

public MyList<E> mergeSort(Collection<? extends E> list1) {
    //Copy this list in another one and clear it
    List<E> list2 = new ArrayList<E>(this);
    this.clear();
    //Merge values until one list is exhausted
    Iterator<? extends E> it1 = list1.iterator();
    Iterator<? extends E> it2 = list2.iterator();
    if (it1.hasNext() && it2.hasNext()) {
        E value1 = it1.next(), value2 = it2.next();
        do {
            if (value1.compareTo(value2) <= 0) {
                this.add(value1);
                if (it1.hasNext()) {
                    value1 = it1.next();
                } else {
                    this.add(value2);
                    break;
                }
            } else {
                this.add(value2);
                if (it2.hasNext()) {
                    value2 = it2.next();
                } else {
                    this.add(value1);
                    break;
                }
            }
        } while (true);
    }
    //copy remaining values
    while (it1.hasNext()) {
        this.add(it1.next());
    }
    while (it2.hasNext()) {
        this.add(it2.next());
    }
    return this;
}

我的类定义如下所示：

public class MyList<E extends Comparable<E>>
    extends ArrayList<E> {

Answer 2

我认为您希望就地完成合并？如果是这样，它与普通的合并两个列表问题并没有什么不同。

由于我不熟悉Java，我将编写算法的伪代码版本（假设list1和list2都已经排序）：

let Y refer to the first element in list2
for X in list1 (traversed in ascending order):
    while Y < X:
        insert Y before X
        change Y to point to the next element
while Y is still a valid reference:
    append Y to list1
    change Y to point to the next element

这里的算法破坏性地修改list1并将list2的每个元素插入到正确的位置。如果您希望在比较相等的元素时首选list2，请将< 更改为<=。

Answer 3

List 迭代器维护 插入顺序，因此它们并非真正设计为执行您想要的操作，尽管您可以在使用 Collections.sort() 合并列表后对列表进行排序。

public List<T> mergeSort(List<T> one, List<T> two) {
    List<T> rc = new ArrayList<>(one.size() + two.size());
    rc.addAll(one);
    rc.addAll(two);
    Collections.sort(rc);
    return rc;
}

您可以在此处添加Comparator 以控制排序。

最好使用Set 集合，因为它们会根据类型自动排序。如果你没问题，方法如下：

public Set<T> mergeSort(Set<T> one, Set<T> two) {
    Set<T> rc = new TreeSet<>(one);
    rc.addAll(two);
    return rc;
}

同样，您也可以在此处添加Comparator。

不完全是您想要的，但不是扩展ArrayList 或TreeSet，而是您可以在任何地方使用的通用方法。对于你的问题，我会这样使用它：

list1 = Utility.mergeSort(list1, list2);

Answer 4

你可以构造一个Iterable，它可以合并另外两个Iterables，只要它们是Comparable。

class MergedList<T extends Comparable<T>> implements Iterable<T> {
    // The two Iterables we are merging.
    private final Iterable<T> a;
    private final Iterable<T> b;

    // Varargs version left to the student.
    public MergedList(Iterable<T> a, Iterable<T> b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public Iterator<T> iterator() {
        return new Iterator<T>() {
            // Grab iterators.
            private final Iterator<T> ia = a.iterator();
            private final Iterator<T> ib = b.iterator();
            // Prime both pumps.
            private T na = ia.hasNext() ? ia.next() : null;
            private T nb = ib.hasNext() ? ib.next() : null;
            // Next to deliver.
            private T n = null;

            @Override
            public boolean hasNext() {
                if (n == null) {
                    // Pick one - either null means the other one - otherwise compare.
                    n = na == null ? nb : nb == null ? na : na.compareTo(nb) < 0 ? na : nb;
                    if (n != null) {
                        // Consume one.
                        if (na != null && n == na) {
                            // Get next from a.
                            na = ia.hasNext() ? ia.next() : null;
                        } else if (nb != null && n == nb) {
                            // Get next from b.
                            nb = ib.hasNext() ? ib.next() : null;
                        }
                    }
                }
                return n != null;
            }

            @Override
            public T next() {
                T next = n;
                n = null;
                return next;
            }

        };
    }
}

public void test() {
    List<String> a = Arrays.asList("A", "C", "E");
    List<String> b = Arrays.asList("B", "D", "F");
    for (String s : new MergedList<>(a, b)) {
        System.out.println(s);
    }
}

Answer 5

   public List<Integer> mergeSort(List<Integer> otherList){
        List<Integer> list1 = new ArrayList<>(); // this should be list1
        list1.addAll(otherList);

        /** can also use Collections.sort(list1); */
        Collections.sort(list1,new Comparator<Integer>() {

            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2); //Change to o2.CompareTo(o1) for descending order
            }
        });
        return list1;
    }