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

我使用的方法获取两个排序的列表，并返回一个列表，该列表包含两个原始列表中的所有元素，按排序顺序排列

例如，如果原始列表是（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;
}

公共静态列表合并分类列表（列表a、列表b）{
列表结果=新建ArrayList（）；
PushbackIterator aIter=新的PushbackIterator（a.iterator（））；
PushbackIterator bIter=新的PushbackIterator（b.iterator（））；
while（aIter.hasNext（）&&bIter.hasNext（））{
if（aIter.next（）.compareTo（bIter.next（））<0）{
result.add（aIter.next（））；
}  
如果（bIter.next（）.compareTo（bIter.next（））>0）{
result.add（bIter.next（））；
}
}
while（aIter.hasNext（））{
result.add（aIter.next（））；
}
while（bIter.hasNext（））{
result.add（bIter.next（））；
}
返回结果；
}

为了执行合并，您需要查看下一个值，以便查看要使用的下一个值

最终，其中一个列表的值将在另一个列表之前用完，因此您需要检查该列表

一个技巧是使用

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;
}

输出

---

我假设您使用了

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);
    }
}

while（aIter.hasNext（）&&bIter.hasNext（））{
E aElem=aIter.next（）；
E bElem=bIter.next（）；
if（aElem.compareTo（bElem）合并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());
    }

}

static void printItr（迭代器it1、迭代器it2）{
字符串firstString=null，secondString=null；
布尔值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（第一个字符串）；
moveaheadt2=假；
moveaheadt1=真；
}否则{
System.out.println（第二个字符串）；
moveaheadt1=假；
moveaheadt2=真；
}
}
while（it1.hasNext（））{
System.out.println（it1.next（））；
}
while（it2.hasNext（））{
System.out.println（it2.next（））；
}
}
这不起作用，因为有很多原因。例如，对于给定的步骤，您要调用两次
next（）
。您忘记了为什么要使用
pushback迭代器了吗？我正在寻找一种纯Java的方法来合并两个排序迭代器，您的答案是迄今为止我找到的最佳解决方案。
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);
    }
}

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());
    }

}