Question

我使用的方法采用两个排序列表，并按排序顺序返回包含两个原始列表中所有元素的单个列表。

例如，如果原始列表是（1,4,5）和（2,3,6），那么结果列表将是（1,2,3,4,5,6）。

我有什么遗失的吗？

public static<E extends Comparable<E>> List<E> mergeSortedLists(List<E> a, List<E> b) {
    List<E> result = new ArrayList<E>();

    PushbackIterator<E> aIter = new PushbackIterator<E>(a.iterator());
    PushbackIterator<E> bIter = new PushbackIterator<E>(b.iterator());

    while (aIter.hasNext() && bIter.hasNext()) {
        if (aIter.next().compareTo(bIter.next()) < 0) {
            result.add(aIter.next());
        }  
        if (bIter.next().compareTo(bIter.next()) > 0){
            result.add(bIter.next());
        }
    }
    while (aIter.hasNext()) {
        result.add(aIter.next());
    }
    while (bIter.hasNext()) {
        result.add(bIter.next());
    }
    return result;
}

Answer 1

为了执行合并，您需要查看下一个值，因此请查看要使用的下一个值。

最终，其中一个列表会在另一个列表之前耗尽值，因此您需要检查它。

一个技巧是使用null作为数据结束标记，假设列表不能包含null值，这是一个公平的假设，因为它们必须进行排序。在这种情况下，代码将是这样的：

public static <E extends Comparable<E>> List<E> mergeSortedLists(List<E> list1, List<E> list2) {
    List<E> merged = new ArrayList<>(list1.size() + list2.size());

    // Get list iterators and fetch first value from each, if available
    Iterator<E> iter1 = list1.iterator();
    Iterator<E> iter2 = list2.iterator();
    E value1 = (iter1.hasNext() ? iter1.next() : null);
    E value2 = (iter2.hasNext() ? iter2.next() : null);

    // Loop while values remain in either list
    while (value1 != null || value2 != null) {

        // Choose list to pull value from
        if (value2 == null || (value1 != null && value1.compareTo(value2) <= 0)) {

            // Add list1 value to result and fetch next value, if available
            merged.add(value1);
            value1 = (iter1.hasNext() ? iter1.next() : null);

        } else {

            // Add list2 value to result and fetch next value, if available
            merged.add(value2);
            value2 = (iter2.hasNext() ? iter2.next() : null);

        }
    }

    // Return merged result
    return merged;
}

测试

System.out.println(mergeSortedLists(Arrays.asList(1, 4, 5),
                                    Arrays.asList(2, 3, 6)));

输出

[1, 2, 3, 4, 5, 6]

Answer 2

我假设您使用PushbackIterator：

打算这样做

while (aIter.hasNext() && bIter.hasNext()) {
    E aElem = aIter.next();
    E bElem = bIter.next();
    if (aElem.compareTo(bElem) <= 0) {
        result.add(aElem);
        bIter.pushback(bElem);
    } else {
        result.add(bElem);
        aIter.pushback(aElem);
    }
}

Answer 3

合并2个数组的相同方法也可以与迭代器稍微调整一起使用。如果需要，您可以使用添加元素而不是打印。

static void printItr(Iterator<String> it1, Iterator<String> it2) {
    String firstString=null,secondString = null;
    boolean moveAheadIt1 = true, moveAheadIt2 = true;

    while(it1.hasNext() && it2.hasNext()){
         firstString = moveAheadIt1 ? it1.next() : firstString ;
         secondString = moveAheadIt2 ? it2.next() : secondString;

         if(firstString.compareTo(secondString) < 0){
            System.out.println(firstString);
            moveAheadIt2 = false;
            moveAheadIt1 = true;
        }else {
            System.out.println(secondString);
            moveAheadIt1 = false;
            moveAheadIt2 = true;
        }
    }

    while(it1.hasNext()){
        System.out.println(it1.next());
    }
    while(it2.hasNext()){
        System.out.println(it2.next());
    }

}

将排序列表与Java中的迭代器合并

3 个答案: