0 / 1.0

Consider the following class definitions:

public class LinkedChain<T> { private Node<T> firstNode; private int...

X786: Insert At Reference

Consider the following class definitions:

public class LinkedChain<T> {
    private Node<T> firstNode;
    private int numberOfEntries;

    public LinkedChain() {
        firstNode = null;
        numberOfEntries = 0;
    }// end default constructor


    public Node<T> getfirstNode() {
        return firstNode;
    }


    public int getNumberOfEntries() {
        return numberOfEntries;
    }



    public void push(T newEntry) {
        // TODO Auto-generated method stub
        firstNode = new Node<T>(newEntry, firstNode);
        numberOfEntries++;
    }
}

Where Node is defined as:

public class Node<T> {
     private T data; // Entry in bag
     private Node<T> next; // Link to next node

     public Node(T dataPortion) {
         this(dataPortion, null);
     } // end constructor


     public Node(T dataPortion, Node<T> nextNode) {
         data = dataPortion;
         next = nextNode;
     } // end constructor


     public T getData() {
         if (data != null) {
             return data;
         }
         return null;
     }


     public Node getNext() {
         return next;
     }


     public void setNext(Node<T> newNext) {
         next = newNext;
     }
}

Below, write a Linked Chain method. This method will take in a node in the chain and another linked chain object. You will need to write the code to insert the second list after the reference.

For example, if the linked chain looked like this:

A --> B --> C --> D

and the parameters were:

list1Ref = // a reference to the node containing A in the above chain
newLinkedChain = // X --> Y --> Z

this method would change the chain to:

A --> X --> Y --> Z --> B --> C --> D

If the node referenced is null or not in the linked chain, the code should not alter the linked chain.

Your Answer:

Answer code

// question 13
public boolean nodeInChain(Node<T> list1Ref) {
    Node<T> current = this.getfirstNode();
    while(current!=null) {
        if (current.equals(list1Ref)) {
            return true;
        }
        current = current.getNext();
    }
    return false;
}
public void combineLinkedChains(Node<T> list1Ref, LinkedChain<T> newLinkedChain) {
    if (nodeInChain(list1Ref) == true) {
        Node<T> newNext = newLinkedChain.getfirstNode();

        Node<T> lastNewNode = newLinkedChain.getfirstNode();
        while(lastNewNode.getNext() != null) {
            lastNewNode = lastNewNode.getNext();
        }
        Node<T> oldNext = list1Ref.getNext();

        list1Ref.setNext(newNext);
        lastNewNode.setNext(oldNext);
        numberOfEntries = numberOfEntries + newLinkedChain.getNumberOfEntries();
    }

}

Reset

Visualize

Next exercise

Feedback

Your feedback will appear here when you check your answer.