在双向链表中旧链表之后添加新链表

Question

Hello there I have an interface;

public interface List<Type> {
    void addAll(List<Type> list);
    int addAll(int index, List<Type> list);    
}

and a clear implementation as you see ;

public  class DoublyLinkedList<Type> implements List<Type> {
    @Override
    public void addAll(List<Type> list) {
        Node<Type> old = first();  //returns old linked list.Also I can call the tail node with 
        // tail variable.
    }
    
    @Override
    public int addAll(int index, List<Type> list) {
        // TODO Auto-generated method stub
        return 0;
    }
}

and have a constructor class;

public class Node<Type> {
        
    protected Type data;
    protected Node<Type> next;
    protected Node<Type> previous;
            
            
    public Node(Type data, Node<Type> next,Node<Type> previous) {
        this.data = data;
        this.next = next;
        this.previous = previous;       
    }
            
    public Type getData() {
        return data;
    }
            
    public Node<Type> getNext() {
        return next;
    }
    
    public Node<Type> getPrevious() {
        return previous;
    }
}

I didn't put my all methods above. Because of my project so, my problem is how can I implement the methods? I want to add a new linked list after the old one by the interface.

Answer 1

There are probably different ways to implement your requirements. Below is my implementation. Note that I changed the names. I named the interface Listing so as not to clash with java.util.List . Also the convention for type parameters is a single, capital letter so I changed Type to T . I changed class Node to ListNode because there are already lots of Node classes. I also added a toString() method to class ListNode and also to class DoublyLinkedList as a testing aid. I also added method main() to class DoublyLinkedList to make it possible to test the implementation. Finally, I added method add() to class DoublyLinkedList to make it possible to create non-empty lists.

Explaining how the below code works would involve a lot of text and probably also several diagrams. Rather than do that, I suggest you simply run the code in a debugger. Most IDE's have a debugger.

Interface Listing

public interface Listing<T> {

    /**
     * Append 'list' to the end of this 'Listing'.
     *
     * @param list list to append.
     */
    void addAll(Listing<T> list);

    /**
     * Insert 'list' after element at 'index'. If 'index' greater than size of this
     * 'Listing', append 'list' to this 'Listing'.
     *
     * @param index insertion index
     * @param list  list to insert
     *
     * @return The index after which 'list' was inserted.
     */
    int addAll(int index, Listing<T> list);
}

Class ListNode

public class ListNode<T> {
    protected T data;
    protected ListNode<T> next;
    protected ListNode<T> previous;

    public ListNode(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }

    public ListNode<T> getNext() {
        return next;
    }

    public ListNode<T> getPrevious() {
        return previous;
    }

    public String toString() {
        return String.format("<-%s->", String.valueOf(data));
    }
}

Class DoublyLinkedList

public class DoublyLinkedList<T> implements Listing<T> {
    private ListNode<T> head;

    public void add(T data) {
        ListNode<T> newNode = new ListNode<T>(data);
        if (head == null) {
            head = newNode;
        }
        else {
            ListNode<T> current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
            newNode.previous = current;
        }
    }

    @Override
    public void addAll(Listing<T> list) {
        if (list instanceof DoublyLinkedList) {
            DoublyLinkedList<T> lst = (DoublyLinkedList<T>) list;
            if (lst.head != null) {
                if (head == null) {
                    head = lst.head;
                }
                else {
                    ListNode<T> current = head;
                    while (current.next != null) {
                        current = current.next;
                    }
                    current.next = lst.head;
                    lst.head.previous = current;
                }
            }
        }
    }

    @Override
    public int addAll(int index, Listing<T> list) {
        if (index < 0) {
            throw new IllegalArgumentException("Negative index.");
        }
        int counter = 0;
        if (list instanceof DoublyLinkedList) {
            DoublyLinkedList<T> lst = (DoublyLinkedList<T>) list;
            if (lst.head != null) {
                if (head == null) {
                    if (index == 0) {
                        head = lst.head;
                    }
                }
                else {
                    ListNode<T> current = head;
                    while (current.next != null && counter < index) {
                        counter++;
                        current = current.next;
                    }
                    if (counter < index) {
                        current.next = lst.head;
                        lst.head.previous = current;
                    }
                    else {
                        current.previous.next = lst.head;
                        ListNode<T> tmp = current;
                        ListNode<T> curr = lst.head;
                        while (curr.next != null) {
                            curr = curr.next;
                        }
                        curr.next = tmp;
                        curr.previous = tmp.previous;
                        tmp.previous = curr;
                    }
                }
            }
        }
        return counter;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        if (head != null) {
            ListNode<T> current = head;
            while (current != null) {
                sb.append(current);
                current = current.next;
            }
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        DoublyLinkedList<String> list1 = new DoublyLinkedList<>();
        list1.add("One");
        DoublyLinkedList<String> list2 = new DoublyLinkedList<>();
        list2.add("First");
        list1.addAll(list2);
        System.out.println(list1);
        DoublyLinkedList<String> list3 = new DoublyLinkedList<>();
        list3.add("TOO");
        int result = list1.addAll(1, list3);
        System.out.printf("[%d] %s%n", result, list1);
    }
}