public class MyLinkedListltE extends ComparableltEgtg.pdf

public class MyLinkedList<E extends Comparable<E>> {
private Node<E> head, tail;
private int size = 0; // Number of elements in the list
public MyLinkedList() {
head=tail=null;
size=0;
}
/** Return the head element in the list */
public E getFirst() {
if (size == 0) {
return null;
}
else {
return head.element;
}
}
/** Return the last element in the list */
public E getLast() {
if (size == 0) {
return null;
}
else {
return tail.element;
}
}
/** Add an element to the beginning of the list */
public void addFirst(E e) {
Node<E> newNode = new Node<>(e); // Create a new node
newNode.next = head; // link the new node with the head
head = newNode; // head points to the new node
size++; // Increase list size
if (tail == null) // the new node is the only node in list
tail = head;
}
/** Add an element to the end of the list */
public void addLast(E e) {
Node<E> newNode = new Node<>(e); // Create a new for element e

if (tail == null) {
head = tail = newNode; // The new node is the only node in list
}
else {
tail.next = newNode; // Link the new with the last node
tail = newNode; // tail now points to the last node
}
size++; // Increase size
}
public void add(int index, E e) {
if (index == 0) {
addFirst(e);
}
else if (index >= size) {
addLast(e);
}
else {
Node<E> current = head;
for (int i = 1; i < index; i++) {
current = current.next;
}
Node<E> temp = current.next;
current.next = new Node<>(e);
(current.next).next = temp;
size++;
}
}
//Add e to the end of this linkedlist
public void add(E e) {
// Left as Exercise
}
/** Remove the head node and
* return the object that is contained in the removed node. */
public E removeFirst() {

if (size == 0) {
return null;
}
else {
E temp = head.element;
head = head.next;
size--;
if (head == null) {
tail = null;
}
return temp;
}
}
/** Remove the last node and
* return the object that is contained in the removed node. */
public E removeLast() {
if (size == 0) {
return null;
}
else if (size == 1) {
E temp = head.element;
head = tail = null;
size = 0;
return temp;
}
else {
for (int i = 0; i < size - 2; i++) {
}
E temp = tail.element;
tail = current;
tail.next = null;
size--;
return temp;
}
}
/** Remove the element at the specified position in this
* list. Return the element that was removed from the list. */
public E remove(int index) {

if (index < 0 || index >= size) {
return null;
}
else if (index == 0) {
return removeFirst();
}
else if (index == size - 1) {
return removeLast();
}
else {
Node<E> previous = head;
for (int i = 1; i < index; i++) {
previous = previous.next;
}
Node<E> current = previous.next;
previous.next = current.next;
size--;
return current.element;
}
}
/** Clear the list */
public void clear() {
size = 0;
head = tail = null;
}
/** Override toString() to return elements in the list in [] separated by , */
public String toString() {
StringBuilder result = new StringBuilder("[");
for (int i = 0; i < size; i++) {
result.append(current.element);
if (current != null) {
result.append(", "); // Separate two elements with a comma
}
else {

result.append("]"); // Insert the closing ] in the string
}
}
return result.toString();
}
/** Return true if this list contains no elements */
public boolean isEmpty() {
return size==0;
}
/** Return the number of elements in this list */
public int size() {
// Left as exercise
return 0;
}
/** Remove the first occurrence of the element e
* from this list. Return true if the element is removed. */
public boolean remove(E value)
{
// Left as Exercise
return false;
}
/** Adds a new node containing new value after the given index. */
void addAfter(int index, E value)
{
// Left as exercise
}
/** replaces the data in the node at position index with newValue,
* if such a position is in the list and returns the previous (old) value that was at that location.
* Prints an error message and returns null if index is out of range. */
public E set(int index, E e) {
// Left as an exercise
return null;
}
/** Remove all the occurrences of the element e
* from this list. Return true if the element is removed. */
public boolean removeAll(E e) {
// Left as Exercise
return true;

}
/** Return the index of the last matching element in
* this list. Return -1 if no match. */
public int lastIndex(E e) {
// Left as an exercise
return -1;
}
/** returns a new copy of the LinkedList. It creates a copy of MyLinkedList.java.
* It creates a new instance of the class of the current object and initializes all its
* fields with exactly the contents of the corresponding fields of this object. */
public MyLinkedList<E> clone(){
// Left as exercise
return null;
}
/** Check to see if this list contains element e */
public boolean contains(E e) {
// Left as Exercise
return false;
}
/** Add a new element at the specified index in this list in ascending order */
public void addInOrder(E value) {
// Left as Exercise
}
/** Overrides the equals method (found in the Object class). */
public boolean equals(Object o) {
// Left as exercise
return true;
}
/** Split the original list in half. The original
* list will continue to reference the
* front half of the original list and the method
* returns a reference to a new list that stores the
* back half of the original list. If the number of
* elements is odd, the extra element should remain
* with the front half of the list. */
public MyLinkedList<E> split(){
// Left as Exercise

return null;
}
/** Print this list in reverse order */
public void printList() {
// Left as Exercise
}
private static class Node<E> {
E element;
Node<E> next;
public Node(E element) {
this.element = element;
}
}
}

public class MyLinkedListltE extends ComparableltEgtg.pdf

More Related Content

Similar to public class MyLinkedListltE extends ComparableltEgtg.pdf (20)

More from accostinternational (20)

Recently uploaded (20)

public class MyLinkedListltE extends ComparableltEgtg.pdf