Using java modify the doubly linked list class presented in this chapter so it works with generic…

Using java modify the doubly linked list class presented in this chapter so it works with generic…
Using java modify the doubly linked list class presented in this chapter so it works with generic types.
Add the following methods drawn from the java.util.List interface:
• void clear(): remove all elements from the list.
• E get(int index): return the element at position index in the list.
• E set(int index, E element): replace the element at the specified position with
the specified element and return the previous element.
Test your generic linked list class by processing a list of numbers of type double. /**
The DLinkedList class implements a doubly
Linked list.
*/ class DLinkedList
{
/**
The Node class stores a list element
and a reference to the next node.
*/
private class Node
{
String value; // Value of a list element
Node next; // Next node in the list
Node prev; // Previous element in the list

/**
Constructor.
@param val The element to be stored in the node.
@param n The reference to the successor node.
@param p The reference to the predecessor node.
*/

Node(String val, Node n, Node p)
{
value = val;
next = n;
prev = p;
}

/**
Constructor.
@param val The element to be stored in the node.
*/

Node(String val)
{
// Just call the other (sister) constructor
this(val, null, null);
}
}

private Node first; // Head of the list
private Node last; // Last element on the list

/**
Constructor.
*/

public DLinkedList()
{
first = null;
last = null;
}

/**
The isEmpty method checks to see if the list
is empty.
@return true if list is empty, false otherwise.
*/

public boolean isEmpty()
{
return first == null;
}

/**
The size method returns the length of the list.
@return The number of elements in the list.
*/

public int size()
{
int count = 0;
Node p = first;
while (p != null)
{
// There is an element at p
count ++;
p = p.next;
}
return count;
}

/**
The add method adds to the end of the list.
@param e The value to add.
*/

public void add(String e)
{
if (isEmpty())
{
last = new Node(e);
first = last;
}
else
{
// Add to end of existing list
last.next = new Node(e, null, last);
last = last.next;
}
}

/**
This add method adds an element at an index.
@param e The element to add to the list.
@param index The index at which to add.
@exception IndexOutOfBoundsException
When the index is out of bounds.
*/

public void add(int index, String e)
{
if (index < 0="" ||="" index=""> size())
{
String message = String.valueOf(index);
throw new IndexOutOfBoundsException(message);
}

// Index is at least 0
if (index == 0)
{
// New element goes at beginning
Node p = first; // Old first
first = new Node(e, p, null);
if (p != null)
p.prev = first;
if (last == null)
last = first;
return;
}

// pred will point to the predecessor
// of the new node.
Node pred = first;
for (int k = 1; k <= index="" -="" 1;="">
{
pred = pred.next;
}

// Splice in a node with the new element
// We want to go from pred– succ to
// pred–middle–succ
Node succ = pred.next;
Node middle = new Node(e, succ, pred);
pred.next = middle;
if (succ == null)
last = middle;
else
succ.prev = middle;
}

/**
The toString method computes the string
representation of the list.
@return The string representation of the
linked list.
*/

public String toString()
{
StringBuilder strBuilder = new StringBuilder();

// Use p to walk down the linked list
Node p = first;
while (p != null)
{
strBuilder.append(p.value + “n”);
p = p.next;
}
return strBuilder.toString();
}

/**
The remove method removes the element
at a given position.
@param index The position of the element
to remove.
@return The element removed.
@exception IndexOutOfBoundsException When
index is out of bounds.
*/

public String remove(int index)
{
if (index < 0="" ||="" index="">= size())
{
String message = String.valueOf(index);
throw new IndexOutOfBoundsException(message);
}

// Locate the node targeted for removal
Node target = first;
for (int k = 1; k <= index;="">
target = target.next;

String element = target.value; // Element to return
Node pred = target.prev; // Node before the target
Node succ = target.next; // Node after the target

// Route forward and back pointers around
// the node to be removed
if (pred == null)
first = succ;
else
pred.next = succ;

if (succ == null)
last = pred;
else
succ.prev = pred;

return element;
}

/**
The remove method removes an element from the list.
@param element The element to remove.
@return true if the element was removed, false otherwise.
*/

public boolean remove(String element)
{
if (isEmpty())
return false;

// Locate the node targeted for removal
Node target = first;
while (target != null
&& !element.equals(target.value))
target = target.next;

if (target == null)
return false;

Node pred = target.prev; // Node before the target
Node succ = target.next; // Node after the target

// Route forward and back pointers around
// the node to be removed
if (pred == null)
first = succ;
else
pred.next = succ;

if (succ == null)
last = pred;
else
succ.prev = pred;

return true;
}

public static void main(String [] args)
{
DLinkedList ll = new DLinkedList();
ll.add(“Amy”);
ll.add(“Bob”);
ll.add(0, “Al”);
ll.add(2, “Beth”);
ll.add(4, “Carol”);
System.out.println(“The elements of the list are:”);
System.out.println(ll);
}
}   May 13 2022 07:27 PM

Place your order
(550 words)

Approximate price: $22

Calculate the price of your order

550 words
We'll send you the first draft for approval by September 11, 2018 at 10:52 AM
Total price:
$26
The price is based on these factors:
Academic level
Number of pages
Urgency
Basic features
  • Free title page and bibliography
  • Unlimited revisions
  • Plagiarism-free guarantee
  • Money-back guarantee
  • 24/7 support
On-demand options
  • Writer’s samples
  • Part-by-part delivery
  • Overnight delivery
  • Copies of used sources
  • Expert Proofreading
Paper format
  • 275 words per page
  • 12 pt Arial/Times New Roman
  • Double line spacing
  • Any citation style (APA, MLA, Chicago/Turabian, Harvard)

Our guarantees

Delivering a high-quality product at a reasonable price is not enough anymore.
That’s why we have developed 5 beneficial guarantees that will make your experience with our service enjoyable, easy, and safe.

Money-back guarantee

You have to be 100% sure of the quality of your product to give a money-back guarantee. This describes us perfectly. Make sure that this guarantee is totally transparent.

Read more

Zero-plagiarism guarantee

Each paper is composed from scratch, according to your instructions. It is then checked by our plagiarism-detection software. There is no gap where plagiarism could squeeze in.

Read more

Free-revision policy

Thanks to our free revisions, there is no way for you to be unsatisfied. We will work on your paper until you are completely happy with the result.

Read more

Privacy policy

Your email is safe, as we store it according to international data protection rules. Your bank details are secure, as we use only reliable payment systems.

Read more

Fair-cooperation guarantee

By sending us your money, you buy the service we provide. Check out our terms and conditions if you prefer business talks to be laid out in official language.

Read more
Open chat
1
You can contact our live agent via WhatsApp! Via + 1 (409) 205-8984

Feel free to ask questions, clarifications, or discounts available when placing an order.

Order your essay today and save 30% with the discount code DISCOUNT