java结合两个链表

Question

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

这是我的解决方案。有没有更有效的方法可以在不循环第一个链表的情况下做到这一点？任何建议将不胜感激。

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

Answer 1

使用list1.addAll(list2) 将list2 附加到list1 的末尾。

Answer 2

对于链表，linkedList.addAll(otherlist) 似乎是个很差的选择。

linkedList.addAll的java api版本开始：

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

因此，即使您有 2 个链表，第二个链表也会转换为数组，然后重新组合成单​​独的元素。这比仅仅合并 2 个数组更糟糕。

Answer 3

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

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

Answer 4

最好的方法是将第二个列表附加到第一个列表。

1。创建一个节点类。

2。创建新的 LinkedList 类。

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

3。在 Main 函数或任何您希望此附加发生的地方，都可以这样做。

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

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

希望有帮助

Answer 5

我的总代码：

注意：不使用 JAVA API

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

}