将两个链表（顺序）结合（最后形成的链表的是顺序的）

将两个链表（顺序）结合（最后形成的链表的是顺序的）

比如 1<4<5 ; 2<4<6
变为：1<2<4<4<5<6
想法：从两个链表中取两个头节点进行比较，如果较小，下标则后移。循环遍历直到两个链表都为空。

//节点
public class Node<T> {
    public T value;
    public Node<T> next;

    public Node(){

    }
    public Node(T value) {
        this.value = value;
        this.next=null;
    }
}

package Collection.linked;

import java.util.LinkedList;

//将两个链表(链表的节点数据大小为顺序)顺序结合起来
public class TwoLinkedMerge {
    //以节点的形式
    public static Node<Integer> mergeNode(Node<Integer> node1,Node<Integer> node2){
        //需要返回的头节点
        Node<Integer> startNode=new Node<>();
        //下标节点，主要用来记录当前节点的位置
        Node<Integer> indexNode=startNode;
        //当两个链表头节点不为null,表示没有遍历结束。
        while (node1!=null||node2!=null){
            //如果一个节点遍历结束，则只将另一个节点复制到indexNode后
            if(node1==null){
                indexNode.next=node2;
                indexNode=indexNode.next;
                node2=node2.next;
                continue;
            }
            if(node2==null){
                indexNode.next=node1;
                indexNode=indexNode.next;
                node1=node1.next;
                continue;
            }

            //比较两个节点的数据大小，将小节点复制到indexNode后，同时源节点后移
            if(node1.value>node2.value){
                indexNode.next=node2;
                indexNode=indexNode.next;
                node2=node2.next;
            }else {
                indexNode.next=node1;
                indexNode=indexNode.next;
                node1=node1.next;
            }
        }
        return startNode.next;
    }
    //以集合的形式
    public static LinkedList<Integer> mergeList(LinkedList<Integer> list1,LinkedList<Integer> list2){
        int index1=0,index2=0;
        LinkedList<Integer> integers = new LinkedList<>();
        while(index1<list1.size()||index2<list2.size()){
            if(index1>=list1.size()){
                integers.add(list2.get(index2));
                index2++;
                continue;
            }
            if (index2>=list2.size()){
                integers.add(list1.get(index1));
                index1++;
                continue;
            }
            if(list1.get(index1)>list2.get(index2)){
                integers.add(list2.get(index2));
                index2++;
            }else {
                integers.add(list1.get(index1));
                index1++;
            }
        }
        return integers;
    }
}

运行：

package Collection.linked;

import java.util.Iterator;
import java.util.LinkedList;

public class NodeClass {
    public static void main(String[] args) {
        NodeClass nodeClass = new NodeClass();
        nodeClass.two();

    }
    //已节点的形式表示
    public void one(){
        Node<Integer> node1=new Node<>(1);
        node1.next=new Node<>(5);
        node1.next.next=new Node<>(6);
        node1.next.next.next=new Node<>(10);

        Node<Integer> node2=new Node<>(1);
        node2.next=new Node<>(2);
        node2.next.next=new Node<>(3);
        node2.next.next.next=new Node<>(6);

        TwoLinkedMerge merge = new TwoLinkedMerge();
        Node<Integer> merge1 = TwoLinkedMerge.mergeNode(node1, node2);

        while (merge1!=null){
            System.out.println(merge1.value);
            merge1=merge1.next;
        }
    }

    public void two(){
        //已集合链表的形式表示
        LinkedList<Integer> integers1 = new LinkedList<>();
        LinkedList<Integer> integers2 = new LinkedList<>();

        integers1.add(1);
        integers1.add(2);
        integers1.add(3);
        integers1.add(4);
        integers1.add(5);

        integers2.add(1);
        integers2.add(2);
        integers2.add(3);
        integers2.add(4);
        integers2.add(5);

        LinkedList<Integer> integers = TwoLinkedMerge.mergeList(integers1, integers2);
        Iterator<Integer> iterator = integers.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}