Question

Writing a method retainAll for Circular Doubly-Linked List:

I am working on an assignment creating a Circular Doubly Linked List and am having serious trouble creating a method retainAll. Here's the code, and my attempt.

Initialization:

public class CDoublyLinkedList {
   private class Node {
       private Object data; //Assume data implemented Comparable
       private Node next, prev;
       private Node(Object data, Node pref, Node next)
       {
           this.data = data;
           this.prev = pref;
           this.next = next;
       }
   }

   private Node head;
   private int size;

   public CDoublyLinkedList() {
       this.head = new Node(null, null, null );
       this.head.next = this.head;
       this.head.prev=this.head;
       this.size = 0;
   }

public boolean isEmpty() {
       return this.head == this.head.next;
   }

Method instructions and attempted method:

// Removes from this list all of its elements that
   // are NOT contained in the specified linkedlist other.
   // If any element has been removed from this list,
   // returns true. Otherwise returns false.
   // If other list is null, throws NullPointerException.
// Helper methods are allowed.
   public boolean retainAll(CDoublyLinkedList other) throws NullPointerException {
       Node cur = this.head.next;
       Node cur1 = other.head.next;
       if (other == null) {
           throw new NullPointerException("NullPointerException");
       }
      
       while (cur!= this.head) {
           if (cur.data == null) {
                   cur = cur.next;
                   cur1 = cur1.next;
           }
              
           }
           if (!cur.data.equals(cur1.data)) {
               cur.prev.next = cur.next;
               cur.next.prev = cur.prev;
               this.size--;
               return true;
           }
          
           return false;
       }

Here is the tester class, and the proper output.
public class Tester {
   private static CDoublyLinkedList list0;
   private static CDoublyLinkedList list2;
   private static CDoublyLinkedList list3;
  
   private static void init() {
       list0 = new CDoublyLinkedList();
       list2 = new CDoublyLinkedList();
       list3 = new CDoublyLinkedList();
       list2.addFirst("6:Tony");
       list2.addFirst("5:Tom");
       list2.addFirst("4:Tim");
       list2.addFirst("3:Abby");
       list2.addFirst("2:Morning");
       list2.addFirst("1:Good");
       list0.addFirst(null);
       list0.addFirst("bad");
       list0.addFirst("apple");
       list0.addFirst(null);
   }
   public static void drawLine() {
       System.out.println("-----------------------------");
   }

public static void testRetainAll() {
       init();
       System.out.println("---------testRetainAll()---------");
       list3.retainAll(list0);
       System.out.println(list3);
       list3.addFirst("C");
       list3.addFirst("C");
       list3.addFirst("6:Tony");
       list3.addFirst("6:Tony");
       list3.retainAll(list2);
       System.out.println(list3);
       init();
       list3.addFirst(null);
       list3.addFirst("bad");
       list3.addFirst(null);
       list3.addFirst("B");
       list3.addFirst("A");
       list3.retainAll(list0);
       System.out.println(list3);
       drawLine();
   }

---------testRetainAll()---------

{}

{6:Tony->6:Tony}

{null->bad->null}

-----------------------------

  

Please help, I have been scratching my head about this for several hours now.

Answer 1

public class CDoublyLinkedList {
        private class Node {
                private Object data; // Assume data implemented Comparable
                private Node next, prev;

                private Node(Object data, Node pref, Node next) {
                        this.data = data;
                        this.prev = pref;
                        this.next = next;
                }
        }

        private Node head;
        private int size;

        public CDoublyLinkedList() {
                this.head = new Node(null, null, null);
                this.head.next = this.head;
                this.head.prev = this.head;
                this.size = 0;
        }

        public boolean isEmpty() {
                return this.head == this.head.next;
        }
        
        public boolean contains(Object data) {
                Node start = head.next;
                int len = size;
                
                while(len != 0) {
                        if(start.data != null && start.data.equals(data)) {
                                return true;
                        }
                        start = start.next;
                }
                return false;
        }
        
        private void removeNode(Node x) {
                Node prevNode = x.prev;
                Node nextNode = x.next;
                
                prevNode.next = nextNode;
                nextNode.prev = prevNode;
                size--;
        }

        // Removes from this list all of its elements that
        // are NOT contained in the specified linkedlist other.
        // If any element has been removed from this list,
        // returns true. Otherwise returns false.
        // If other list is null, throws NullPointerException.
        // Helper methods are allowed.
        public boolean retainAll(CDoublyLinkedList other) throws NullPointerException {
                Node cur = this.head.next;
                boolean status = false;
                while(cur != this.head) {
                        Node nextNode = cur.next;
                        if(!other.contains(cur.data)) {
                                removeNode(cur);
                                status = true;
                        }
                        cur = nextNode;
                }

                return status;
        }
}

please use above code.. make very simply. Hope it helps.