I'm doing a LinkedList class of my own, and I'm trying to implement clear, and I'm not sure what to do. what I was thinking about doing is traversing the list and setting every node to null, but I have a reference to the first node in the list, and I've heard that I can simply do
first = null;
and that will be enough. Is that right, or do I need to traverse the list EDIT: I'd been advised to show the rest of my code. Not everything is implemented yet, but I hope it helps.
import java.util.Iterator;
public class MyALDAList <E> implements ALDAList<E> {
@Override
public void add(E element) {
if (first == null) {
first = last = new MyNode<E>(element, null);
}
else {
MyNode<E> newNode = new MyNode<E> (element, null);
last.next = newNode;
last = newNode;
}
lSize ;
modCnt ;
}
@Override
public void add(int index, E element) {
if (index > lSize || index < 0) {
throw new IndexOutOfBoundsException();
}
else {
MyNode<E> newNode = new MyNode<E>(element, null);
if (first == null) {
first = last = newNode;
}
else if (index == 0) {
newNode.next = first;
first = newNode;
}
else {
MyNode<E> indexNode = first;
MyNode<E> prevNode = null;
for (int i = 0; i < index; i ) {
prevNode = indexNode;
indexNode = indexNode.next;
}
prevNode.next = newNode;
newNode.next = indexNode;
}
lSize ;
modCnt ;
}
}
@Override
public E remove(int index) {
E returnData = null;
if (index > lSize || index < 0) {
throw new IndexOutOfBoundsException();
}
else {
if (index == 0) {
MyNode<E> tempHolder = first;
first = first.next;
returnData = tempHolder.data;
tempHolder = null;
}
else {
MyNode<E> indexNode = first;
MyNode<E> prevNode = null;
for (int i = 0; i < index; i ) {
prevNode = indexNode;
indexNode = indexNode.next;
}
returnData = indexNode.data;
prevNode.next = indexNode.next;
indexNode = null;
}
lSize--;
modCnt ;
}
return returnData;
}
@Override
public boolean remove(E element) {
Boolean flag = false;
MyNode<E> indexNode = first;
MyNode<E> prevNode = null;
for (int i = 0; i < lSize; i ) {
if (indexNode.data.equals(element)) {
prevNode.next = indexNode.next;
indexNode = null;
lSize--;
modCnt ;
flag = true;
}
prevNode = indexNode;
indexNode = indexNode.next;
}
return flag;
}
@Override
public E get(int index) {
return null;
}
@Override
public boolean contains(E element) {
return false;
}
@Override
public int indexOf(E element) {
int indexCount = 0;
return 0;
}
@Override
public void clear() {
first = null;
}
@Override
public int size() {
return lSize;
}
@Override
public java.util.Iterator<E> iterator() {
return new MyIterator();
}
private class MyIterator implements java.util.Iterator<E> {
private MyNode<E> current = first;
private int acceptableModCnt = modCnt;
@Override
public boolean hasNext() {
return current.next != null;
}
@Override
public E next() {
if (modCnt != acceptableModCnt) {
throw new java.util.ConcurrentModificationException( );
}
if (!hasNext()) {
throw new java.util.NoSuchElementException( );
}
E returnItem = current.data;
current = current.next;
return returnItem;
}
}
private static class MyNode<E> {
public MyNode(E val, MyNode<E> nextNode) {
data = val;
next = nextNode;
}
private E data;
private MyNode<E> next;
}
int lSize = 0;
int modCnt = 0;
MyNode<E> first = null;
MyNode<E> last = null;
}
import java.util.Iterator;
public class MyALDAList <E> implements ALDAList<E> {
@Override
public void add(E element) {
if (first == null) {
first = last = new MyNode<E>(element, null);
}
else {
MyNode<E> newNode = new MyNode<E> (element, null);
last.next = newNode;
last = newNode;
}
lSize ;
modCnt ;
}
@Override
public void add(int index, E element) {
if (index > lSize || index < 0) {
throw new IndexOutOfBoundsException();
}
else {
MyNode<E> newNode = new MyNode<E>(element, null);
if (first == null) {
first = last = newNode;
}
else if (index == 0) {
newNode.next = first;
first = newNode;
}
else {
MyNode<E> indexNode = first;
MyNode<E> prevNode = null;
for (int i = 0; i < index; i ) {
prevNode = indexNode;
indexNode = indexNode.next;
}
prevNode.next = newNode;
newNode.next = indexNode;
}
lSize ;
modCnt ;
}
}
@Override
public E remove(int index) {
E returnData = null;
if (index > lSize || index < 0) {
throw new IndexOutOfBoundsException();
}
else {
if (index == 0) {
MyNode<E> tempHolder = first;
first = first.next;
returnData = tempHolder.data;
tempHolder = null;
}
else {
MyNode<E> indexNode = first;
MyNode<E> prevNode = null;
for (int i = 0; i < index; i ) {
prevNode = indexNode;
indexNode = indexNode.next;
}
returnData = indexNode.data;
prevNode.next = indexNode.next;
indexNode = null;
}
lSize--;
modCnt ;
}
return returnData;
}
@Override
public boolean remove(E element) {
Boolean flag = false;
MyNode<E> indexNode = first;
MyNode<E> prevNode = null;
for (int i = 0; i < lSize; i ) {
if (indexNode.data.equals(element)) {
prevNode.next = indexNode.next;
indexNode = null;
lSize--;
modCnt ;
flag = true;
}
prevNode = indexNode;
indexNode = indexNode.next;
}
return flag;
}
@Override
public E get(int index) {
return null;
}
@Override
public boolean contains(E element) {
return false;
}
@Override
public int indexOf(E element) {
int indexCount = 0;
return 0;
}
@Override
public void clear() {
first = null;
}
@Override
public int size() {
return lSize;
}
@Override
public java.util.Iterator<E> iterator() {
return new MyIterator();
}
private class MyIterator implements java.util.Iterator<E> {
private MyNode<E> current = first;
private int acceptableModCnt = modCnt;
@Override
public boolean hasNext() {
return current.next != null;
}
@Override
public E next() {
if (modCnt != acceptableModCnt) {
throw new java.util.ConcurrentModificationException( );
}
if (!hasNext()) {
throw new java.util.NoSuchElementException( );
}
E returnItem = current.data;
current = current.next;
return returnItem;
}
}
private static class MyNode<E> {
public MyNode(E val, MyNode<E> nextNode) {
data = val;
next = nextNode;
}
private E data;
private MyNode<E> next;
}
int lSize = 0;
int modCnt = 0;
MyNode<E> first = null;
MyNode<E> last = null;
}
import java.util.Iterator;
public class MyALDAList <E> implements ALDAList<E> {
@Override
public void add(E element) {
if (first == null) {
first = last = new MyNode<E>(element, null);
}
else {
MyNode<E> newNode = new MyNode<E> (element, null);
last.next = newNode;
last = newNode;
}
lSize ;
modCnt ;
}
@Override
public void add(int index, E element) {
if (index > lSize || index < 0) {
throw new IndexOutOfBoundsException();
}
else {
MyNode<E> newNode = new MyNode<E>(element, null);
if (first == null) {
first = last = newNode;
}
else if (index == 0) {
newNode.next = first;
first = newNode;
}
else {
MyNode<E> indexNode = first;
MyNode<E> prevNode = null;
for (int i = 0; i < index; i ) {
prevNode = indexNode;
indexNode = indexNode.next;
}
prevNode.next = newNode;
newNode.next = indexNode;
}
lSize ;
modCnt ;
}
}
@Override
public E remove(int index) {
E returnData = null;
if (index > lSize || index < 0) {
throw new IndexOutOfBoundsException();
}
else {
if (index == 0) {
MyNode<E> tempHolder = first;
first = first.next;
returnData = tempHolder.data;
tempHolder = null;
}
else {
MyNode<E> indexNode = first;
MyNode<E> prevNode = null;
for (int i = 0; i < index; i ) {
prevNode = indexNode;
indexNode = indexNode.next;
}
returnData = indexNode.data;
prevNode.next = indexNode.next;
indexNode = null;
}
lSize--;
modCnt ;
}
return returnData;
}
@Override
public boolean remove(E element) {
Boolean flag = false;
MyNode<E> indexNode = first;
MyNode<E> prevNode = null;
for (int i = 0; i < lSize; i ) {
if (indexNode.data.equals(element)) {
prevNode.next = indexNode.next;
indexNode = null;
lSize--;
modCnt ;
flag = true;
}
prevNode = indexNode;
indexNode = indexNode.next;
}
return flag;
}
@Override
public E get(int index) {
return null;
}
@Override
public boolean contains(E element) {
return false;
}
@Override
public int indexOf(E element) {
int indexCount = 0;
return 0;
}
@Override
public void clear() {
first = null;
}
@Override
public int size() {
return lSize;
}
@Override
public java.util.Iterator<E> iterator() {
return new MyIterator();
}
private class MyIterator implements java.util.Iterator<E> {
private MyNode<E> current = first;
private int acceptableModCnt = modCnt;
@Override
public boolean hasNext() {
return current.next != null;
}
@Override
public E next() {
if (modCnt != acceptableModCnt) {
throw new java.util.ConcurrentModificationException( );
}
if (!hasNext()) {
throw new java.util.NoSuchElementException( );
}
E returnItem = current.data;
current = current.next;
return returnItem;
}
}
private static class MyNode<E> {
public MyNode(E val, MyNode<E> nextNode) {
data = val;
next = nextNode;
}
private E data;
private MyNode<E> next;
}
int lSize = 0;
int modCnt = 0;
MyNode<E> first = null;
MyNode<E> last = null;
}
import java.util.Iterator;
public class MyALDAList <E> implements ALDAList<E> {
@Override
public void add(E element) {
if (first == null) {
first = last = new MyNode<E>(element, null);
}
else {
MyNode<E> newNode = new MyNode<E> (element, null);
last.next = newNode;
last = newNode;
}
lSize ;
modCnt ;
}
@Override
public void add(int index, E element) {
if (index > lSize || index < 0) {
throw new IndexOutOfBoundsException();
}
else {
MyNode<E> newNode = new MyNode<E>(element, null);
if (first == null) {
first = last = newNode;
}
else if (index == 0) {
newNode.next = first;
first = newNode;
}
else {
MyNode<E> indexNode = first;
MyNode<E> prevNode = null;
for (int i = 0; i < index; i ) {
prevNode = indexNode;
indexNode = indexNode.next;
}
prevNode.next = newNode;
newNode.next = indexNode;
}
lSize ;
modCnt ;
}
}
@Override
public E remove(int index) {
E returnData = null;
if (index > lSize || index < 0) {
throw new IndexOutOfBoundsException();
}
else {
if (index == 0) {
MyNode<E> tempHolder = first;
first = first.next;
returnData = tempHolder.data;
tempHolder = null;
}
else {
MyNode<E> indexNode = first;
MyNode<E> prevNode = null;
for (int i = 0; i < index; i ) {
prevNode = indexNode;
indexNode = indexNode.next;
}
returnData = indexNode.data;
prevNode.next = indexNode.next;
indexNode = null;
}
lSize--;
modCnt ;
}
return returnData;
}
@Override
public boolean remove(E element) {
Boolean flag = false;
MyNode<E> indexNode = first;
MyNode<E> prevNode = null;
for (int i = 0; i < lSize; i ) {
if (indexNode.data.equals(element)) {
prevNode.next = indexNode.next;
indexNode = null;
lSize--;
modCnt ;
flag = true;
}
prevNode = indexNode;
indexNode = indexNode.next;
}
return flag;
}
@Override
public E get(int index) {
return null;
}
@Override
public boolean contains(E element) {
return false;
}
@Override
public int indexOf(E element) {
int indexCount = 0;
return 0;
}
@Override
public void clear() {
first = null;
}
@Override
public int size() {
return lSize;
}
@Override
public java.util.Iterator<E> iterator() {
return new MyIterator();
}
private class MyIterator implements java.util.Iterator<E> {
private MyNode<E> current = first;
private int acceptableModCnt = modCnt;
@Override
public boolean hasNext() {
return current.next != null;
}
@Override
public E next() {
if (modCnt != acceptableModCnt) {
throw new java.util.ConcurrentModificationException( );
}
if (!hasNext()) {
throw new java.util.NoSuchElementException( );
}
E returnItem = current.data;
current = current.next;
return returnItem;
}
}
private static class MyNode<E> {
public MyNode(E val, MyNode<E> nextNode) {
data = val;
next = nextNode;
}
private E data;
private MyNode<E> next;
}
int lSize = 0;
int modCnt = 0;
MyNode<E> first = null;
MyNode<E> last = null;
}
CodePudding user response：
The Java environment is equipped with a garbage collector, that is a routine which destroys unused objects and recycles memory used by them. So, generally, in a singly linked list, when you nullify the first pointer, the first element becomes unreferenced and it can be recycled, together with itp next reference.. Then the second element becomes unreferenced ...and so on, so the whole list will get destroyed.
But that depends on additional details. For example, if your code seeks a list for some item and then stores the reference somewhere, it will prevent that referenced object (and all further items, too) from recycling
CodePudding user response：
At first, I would recommend reading about Lists and understanding their concepts.
A LinkedList owns a head. The head points at the first node.
A node has an object and a pointer to the next node.
You should think about possible problems removing a node.
What will happen to the pointers?
This are data structure basics.
As I already mentioned, you will have to understand List concepts to implement a LinkedList.
An answer to ur question:
If it is not necessary to remove the existing nodes u are able to set the head to null.
If it is necessary to remove all existing nodes contained u will have to run through ur list from the back. A possible solution making it easier to run through ur list from the back is to extend the Node with a before pointer.
But it is depending on ur current impl, some code would be great.
Greetings, 1stNox
public class LinkedList<T> {
private Node<T> head;
public LinkedList(Node<T> head) {
this.head = head;
}
public Node<T> getHead() {
return this.head;
}
public void setHead(Node<T> head) {
this.head = head;
}
}
public class Node<T> {
private T value;
private Node next;
public Node(T value, Node next) {
this.value = value;
this.next = next;
}
// Getter & Setter
// ...
}