java合并两个linkedlist

我有一个关于合并两个linkedlist的问题。基本上，我想将一个linkedlist附加到另一个linkedlist

这是我的解决办法。有没有一种更有效的方法不必循环第一个linkedlist？如有任何建议，将不胜感激

    static Node connect(LinkedList list1, LinkedList list2) {
    Node original = list1.first;
    Node previous = null;
    Node current = list1.first;
    while (current != null) {
        previous = current;
        current = current.next;
    }
    previous.next = list2.first;
    return original;
}

---

使用

list1.addAll（list2）

将list2附加到list1的末尾。

我想这是您自己的链表实现？由于只有一个指向下一个元素的指针，在末尾追加的唯一方法是遍历第一个列表中的所有元素

---

但是，您可以存储指向最后一个元素的指针，以使此操作在固定时间内运行（请记住将新列表的最后一个元素更新为添加列表的最后一个元素）。

对于链接列表，linkedList.addAll（otherlist）似乎是一个非常糟糕的选择

linkedList.addAll的java api版本开始于：

public boolean addAll(int index, Collection<? extends E> c) {
    checkPositionIndex(index);
    Object[] a = c.toArray();

---

publicbooleanaddall（int-index，Collection最好的方法是将第二个列表附加到第一个列表

1.创建一个节点类。
2.创建新的LinkedList类。
公共类链接列表{
公共节点头=null；
公共链接列表（）{}
公共无效添加节点（T数据）{
if（head==null）{
head=新节点（数据）；
}否则{
节点电流=头部；
while（curr.getNext（）！=null）{
curr=curr.getNext（）；
}
当前设置下一步（新节点（数据））；
}
}
公共无效附件列表（LinkedList LinkedList）{
if（linkedList.head==null）{
返回；
}否则{
节点curr=linkedList.head；
while（curr！=null）{
addNode（（T）curr.getData（））；
curr=curr.getNext（）；
}
}
}
}

3.在Main函数中，或者无论您希望在何处进行此追加，都要这样做。
LinkedList n=新建LinkedListNode（）。新建LinkedList（）；
n、 addNode（23）；
n、 addNode（41）；
LinkedList n1=新建LinkedListNode（）。新建LinkedList（）；
n1.addNode（50）；
n1.addNode（34）；
n、 附录列表（n1）；

我喜欢这样做，这样就不需要在第一个LinkedList中同时传递这两个参数并再次循环

希望这有助于我的全部代码：

注意：不使用JavaAPI

我不想使用标准Java api。有人问我。如果你真的想重新发明这个轮子，你可以查看集合api的LinkedList的源代码，看看addAll（）是如何实现的。@caesarkim addAll（）似乎在循环中运行，它将所有元素从第二个列表添加到第一个列表，有自己的实现我们可以让列表1的头指向列表2的尾，我认为这可能是使用自己的实现的动机。是的。我也在想同样的事情。但我被问到的问题没有提到关于最后一个指针的任何内容。我猜第一个linkedlist的循环是不可避免的。@caesarkim:获取最后一个指针是你需要低效循环的原因。所以我认为答案是正确的。说真的？！他们在标准库中提供了一个
linkedlist
，但却无法实现链接列表可以高效完成的事情？切碎的能力在没有内存分配或拷贝的情况下，列表并将它们连接在一起是选择链表的原因。那么，他们为什么还要费心提供
LinkedList
？这似乎是更多的证据，表明Java真的根本不关心速度或内存使用。
public class LinkedList<T> {

        public Node<T> head = null;

        public LinkedList() {}

        public void addNode(T data){
            if(head == null) {
                head = new Node<T>(data);
            } else {
                Node<T> curr = head;
                while(curr.getNext() != null) {
                    curr = curr.getNext();
                }
                curr.setNext(new Node<T>(data));
            }
        }

        public void appendList(LinkedList<T> linkedList) {
            if(linkedList.head == null) {
                return;
            } else {
                Node<T> curr = linkedList.head;
                while(curr != null) {
                    addNode((T) curr.getData());
                    curr = curr.getNext();
                }
            }
        }
}

LinkedList<Integer> n = new LinkedListNode().new LinkedList<Integer>();
    n.addNode(23);
    n.addNode(41);
LinkedList<Integer> n1 = new LinkedListNode().new LinkedList<Integer>();
    n1.addNode(50);
    n1.addNode(34);
n.appendList(n1);

class Node {
    Node next;
    int data;
    
    Node(int d){
        data = d;
        next = null;
    }
}
public class OddEvenList {
    
     Node head;
    
    public void push(int new_data){
        Node new_node =  new Node(new_data);
        
        new_node.next = head;
        
        head = new_node;
    }
    
    Node reverse(Node head){
        
        Node prev = null;
        Node next = null;
        Node curr = head;
        
        while(curr != null){
            next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        head = prev;
        
        return head;
    }
    
    Node merge(Node head1, Node head2){
        
        Node curr_odd = head1;
        Node curr_even = head2;
        Node prev = null;
        
        while(curr_odd != null){
            prev = curr_odd;
            curr_odd = curr_odd.next;
        }
        prev.next = curr_even;
        
        return head1;
    }
    
    public void print(Node head){
        Node tnode = head;
        
        while(tnode != null){
            System.out.print(tnode.data + " -> ");
            tnode = tnode.next;
        }
        System.out.println("Null");
        
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        OddEvenList odd = new OddEvenList();
        OddEvenList even = new OddEvenList();
        OddEvenList merge = new OddEvenList();
        
        odd.push(1);
        odd.push(3);
        odd.push(5);
        odd.push(7);
        odd.push(9);
        
        System.out.println("Odd List: ");
        odd.print(odd.head);
        
        System.out.println("Even List: ");
        even.push(0);
        even.push(2);
        even.push(4);
        even.push(6);
        even.push(8);
        
        even.print(even.head);
        
        System.out.println("After Revrse: --------------------");
        Node node_odd =odd.reverse(odd.head);
        Node node_even = even.reverse(even.head);
        
        System.out.println("Odd List: ");
        odd.print(node_odd);
        System.out.println("Even List: ");
        
        even.print(node_even);
        
        System.out.println("Meged: --------------");
        
        Node merged = merge.merge(node_odd, node_even);
    
        merge.print(merged);
    }

}