We Keep Coding

Reverse a linked list recursively in Java [duplicate]

This question already has answers here:
Reversing a linked list in Java, recursively
(33 answers)
Closed 6 years ago.
I am trying to achieve a reversed link list. The new fresh list must be created recursively.
I am creating the first node in the reversed list and I am trying to create a sublist Next which has the next element as next.next and finally to assign this sublist as next to the node. The issue is that the next node remains NIL although I recreated it in the for loop.
Edit:
The function must not change (add arguments) because some tests are running upon it.
class Node {
private Object item;
private Node next,current;
public Node(Object o, Node n) {
this.item = o;
this.next = n;
}
public Node(Node n) {
}
public static final Node NIL = new Node(Node.NIL, Node.NIL);
public Object getItem() {
return this.item;
}
public Node getNext() {
return this.next;
}
public void setItem(Object o) {
this.item = o;
}
public void setNext(Node n) {
this.next = n;
}
// this method returns the item with index number i
public Object nthItem(int i) {
Node p = this;
while (p!=null){
for (int k=1;k<=i;k++){
p=p.next;
}
return p.item;
}
return null;
}
// this method returns the the next item of the node
public Node nthNext(int i) {
Node p = this;
while (p!=null){
for (int k=1;k<=i;k++){
p=p.next;
}
return p.getNext();
}
return null;
}
public Node nthNode(int i) {
Node p = this;
while (p!=null){
for (int k=1;k<=i;k++){
p=p.next;
}
return p;
}
return NIL;
}
public int length(){
if (this == NIL) return 0;
else return 1 + next.length();
}
public Node remove(Object o){
Node p = this;
if (p == NIL) return NIL;
else if(p.item == o) {
p = p.next;
return p.remove(o);
}
else return new Node(p.item, p.next.remove(o));
}
public Node reverse() {
int i = this.length()-1;
if(this == NIL) return NIL;
Node node = new Node(Node.NIL, Node.NIL);
Node next = NIL;
//create the first node in the reversed list
if(i >= 1) node = new Node(nthItem(i), next);
else node = new Node(nthItem(i), Node.NIL);
//iterate through the original list and create a next node
if (i>0) {
for (int k=i; k>=0; k--){
if (k<=0) {
next = NIL;
}
else {
next = new Node(nthItem(k-1),next);
}
}
}
//debugging in console
System.out.println("final node = " + next.item+" ");
return node;
}
}
class Test{
public static void main(String[] string){
Node n = new Node(1, Node.NIL);
Node nn = new Node(2, n);
Node r = nn.reverse();
System.out.println("\t item " + r.getItem()+ " " + r.getNext().getItem() + " length " + r.length());
}
}

This is a question designed to test whether you understand the implicit stack.
Each time you make a recursive call, you add a stack frame, so consider the stack as if you were performing the routine iteratively.
To reverse the list:
Stack all elements in order
Make a new list by popping each element.
Now convert this to a recursive call
//in [1,2,3,null]
Node reverse(Node n){
//base case
if(n == null)
{
return null;
}
// returns [null,3,2,1]
Node next = reverse(n.getNext());
next.setNext(n);// set the next nodes next to its previous(n on unwinding)
return n;
}
Note that the reverse method here doesn't return the new head, to get the head of the reversed list do the following, maybe making a the above a helper instead.
Node oldHead = n;
Node newHead = tail(n);
oldHead.reverse();

Generic Queue, Method to find minimum value

I am implementing a Generic Queue using Linked list. I have the following methods: enqueue, dequeue and peek. I need help with writing a method that will find the minimum value in the queue and throw an exception if the queue is empty.
The code I have so far is:
class Queue <T>
{
private Node front, rear; //begin and end nodes
private int size; // number of items
//nested class to define node
private class Node
{
T item;
Node next;
}
//Zero argument constructor
public Queue()
{
front = null;
rear = null;
size = 0;
}
public boolean isEmpty()
{
return (size == 0);
}
//peek method
public T peek(){
T item = front.item;
return item;
}
//Remove item from the beginning of the list.
public T dequeue()
{
T item = front.item;
front = front.next;
if (isEmpty())
{
rear = null;
}
size--;
return item;
}
//Add T to the end of the list.
public void enqueue(T item)
{
Node oldRear = rear;
rear = new Node();
rear.item = item;
rear.next = null;
if (isEmpty())
{
front = rear;
}
else
{
oldRear.next = rear;
}
size++;
}
public int size()
{
return size;
}
//finds the maximum and minimum in the list
//assumes that head pointer is defined elsewhere
public static void main (String a[])
{
Queue <Integer> q = new Queue<Integer>();
q.enqueue(20);
q.enqueue(30);
q.enqueue(40);
q.enqueue(50);
q.enqueue(60);
q.enqueue(70);
System.out.println("Delete an item from queue: " + q.dequeue());
System.out.println("Size of the queue: " + q.size());
System.out.println("Size of the queue: " + q.peek());
}
}

The below method should find the min value and an exception if Queue is empty
I am throwing a custom "QueueEmptyException"
public Integer findMin(Queue q){
if ( q.size == 0 )
throw new QueueEmptyException();
Integer min = q.front.item;
While (q.front.next != null) {
if ( min > q.front.next.item ) {
min = q.front.next.item
q.front = q.front.next;
}
return min;

Reversing a singly linked list in java

I made a singly linked list from scratch in java. The code is as follows:
public class SingleLinkedList<Item>
{
private Node head;
private int size;
private class Node
{
Item data;
Node next;
public Node(Item data)
{
this.data = data;
this.next = null;
}
public Node(Item data, Node next)
{
this.data = data;
this.next = next;
}
//Getters and setters
public Item getData()
{
return data;
}
public void setData(Item data)
{
this.data = data;
}
public Node getNext()
{
return next;
}
public void setNext(Node next)
{
this.next = next;
}
}
public SingleLinkedList()
{
head = new Node(null);
size = 0;
}
public void add(Item data)
{
Node temp = new Node(data);
Node current = head;
while(current.getNext() != null)
{
current = current.getNext();
}
current.setNext(temp);
size++;
}
public void add(Item data, int index)
{
Node temp = new Node(data);
Node current = head;
for(int i=0; i<index && current.getNext() != null; i++)
{
current = current.getNext();
}
temp.setNext(current.getNext());
current.setNext(temp);
size++;
}
public Item get(int index)
{
if(index <= 0)
{
return null;
}
Node current = head;
for(int i=1; i<index; i++)
{
if(current.getNext() == null)
{
return null;
}
current = current.getNext();
}
return current.getData();
}
public boolean remove(int index)
{
if(index < 1 || index > size())
{
return false;
}
Node current = head;
for(int i=1; i<index; i++)
{
if(current.getNext() == null)
{
return false;
}
current = current.getNext();
}
current.setNext(current.getNext().getNext());
size--;
return true;
}
public String toString()
{
Node current = head.getNext();
String output = "";
while(current != null)
{
output+=current.getData().toString()+" ";
current = current.getNext();
}
return output;
}
public int size()
{
return size;
}
public void reverse()
{
Node current = head;
Node prevNode = null;
Node nextNode;
while(current!=null)
{
nextNode = current.getNext();
current.setNext(prevNode);
prevNode = current;
current = nextNode;
System.out.println(prevNode.getData());
}
head = prevNode;
}
}
As you can see, I added the reverse function in the class only.
But when I tried actually using the class it gave NullPointerException after I tried to reverse it.
To check the functionality I used another class called TEST. The code is as follows:
public class TEST
{
public static void main(String[] args)
{
SingleLinkedList<Integer> list = new SingleLinkedList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
System.out.println(list.toString());
list.reverse();
System.out.println(list.toString());
}
}
The output is as follows:
1 2 3 4 5
null
1
2
3
4
5
Exception in thread "main" java.lang.NullPointerException
at SingleLinkedList.toString(SingleLinkedList.java:129)
at TEST.main(TEST.java:20)
I tried to print the value of prevNode to check whether its not taking values...but it is.
What to do?

Actually, your reverse method looks fine.
The problem is your toString() method.
When you create a new list, you create an initial element whose data is null.
Your toString method skips that first element, so it works fine as long as you don't reverse the list.
But when you reverse the list, that null element becomes the last element, and when you call output+=current.getData().toString()+" "; for that last element when current.getData() is null, you get NullPointerException.
You have several options :
Your reverse method can keep the initial null element first (i.e. reverse the rest of the list, but keep the head the same). This way toString can remain unchanged.
Eliminate the initial null element. Then your toString method doesn't have to skip anything.
Keeping the null element first :
public void reverse()
{
Node current = head.getNext();
Node prevNode = null;
Node nextNode;
while(current!=null)
{
nextNode = current.getNext();
current.setNext(prevNode);
prevNode = current;
current = nextNode;
System.out.println(prevNode.getData());
}
head.setNext(prevNode);
}

The problem is in your SingleLinkedList.java toString() method
Try below it is working fine
public String toString() {
Node current = head;
String output = "";
while (current != null) {
// output += current.getData().toString() + " ";
output += String.valueOf(current.getData()) + " ";
current = current.getNext();
}
return output;
}

while(current!=null)
This is your problem. When you hit the last node the 'next' node you get is actually null.
Try changing it to
while(current!=null&&current.getNext()!=null)
EDIT: Actually not sure that solution will work. Try putting a conditional at the end of your loop that says:
if(current.getNext()==null)
break;
EDIT (again :/):
ok sorry I wasn't thinking straight.
change that final if statement to:
if(current.getNext()==null){
current.setNext(prevNode);
break;
}
The actual nullpointer is in the toString. Here's what you do:
Change the while conditional to
while(current != null&&current.getData()!=null)
Because otherwise if current points to null then you get an exception.
That was exhausting.

Java Linked List [duplicate]

This question already has an answer here:
SLinkedList and Node in Java
(1 answer)
Closed 8 years ago.
I can't seem to figure out why it's printing repeated entries and not printing in order listed. Any thoughts. here is my code for the driver.
ScoresTest
public class ScoresTest
{
public static void main(String[] args)
{
// create
SLinkedList<GameEntry> highScores = new SLinkedList<GameEntry>();
GameEntry entry;
// create entries.
Scores rank = new Scores();
entry = new GameEntry("Rick", 234);
highScores = rank.add(entry, highScores);
entry = new GameEntry("Steve", 121);
highScores = rank.add(entry, highScores);
entry = new GameEntry("Jeremy", 438);
highScores = rank.add(entry, highScores);
entry = new GameEntry("Mike", 925);
highScores = rank.add(entry, highScores);
entry = new GameEntry("Craig", 465);
highScores = rank.add(entry, highScores);
entry = new GameEntry("Juan", 777);
highScores = rank.add(entry,highScores);
System.out.println("The Original High Scores");
rank.print(highScores);
entry = new GameEntry("Tyler", 895);
highScores = rank.add(entry, highScores);
System.out.println("Scores after adding Tyler");
rank.print(highScores);
}
}
GameEntry
public class GameEntry
{
private String name; // name of the person earning this score
private int score; // the score value
// Constructor
public GameEntry(String n, int s)
{
name = n;
score = s;
}
// Get methods.
public String getName() { return name; }
public int getScore() { return score; }
// Return string representation.
public String toString()
{
return "(" + name + ", " + score + ")";
}
}// end class.
Scores
import Project1.SLinkedList.Node;
public class Scores
{
//add function
public SLinkedList<GameEntry> add(GameEntry rank, SLinkedList<GameEntry> scores)
{
Node<GameEntry> currentNode = scores.getFirst();
Node<GameEntry> nextNode = null;
Node<GameEntry> newNode = new Node<GameEntry>();
newNode.setElement(rank);
if(scores.getSize() == 0)
{
scores.addFirst(newNode);
}
else
{
while(currentNode != null)
{
nextNode = currentNode.getNext();
if(nextNode == null)
{
scores.addLast(newNode);
}
else
{
scores.addAfter(currentNode, newNode);
break;
}
currentNode = currentNode.getNext();
}
}
return scores;
}
// Print Format.
public void print(SLinkedList<GameEntry> scores)
{
Node<GameEntry> currentNode = scores.getFirst();
GameEntry currentEntry = currentNode.getElement();
System.out.printf("[");
for(int i = 0; i < scores.getSize(); i++)
{
System.out.printf(", %s", currentEntry.toString());
currentNode = currentNode.getNext();
currentEntry = currentNode.getElement();
}
System.out.println("]");
}
}
SLinkedList
public class SLinkedList<V> implements Cloneable
{
public static class Node<V>
{
// instance variables
private V element;
private Node<V> next;
// methods, constructor first
public Node ()
{
this (null, null); // call the constructor with two args
} // end no argument constructor
public Node (V element, Node<V> next)
{
this.element = element;
this.next = next;
} // end constructor with arguments
// set/get methods
public V getElement ()
{
return element;
}
public Node<V> getNext ()
{
return next;
}
public void setElement (V element)
{
this.element = element;
}
public void setNext (Node<V> next)
{
this.next = next;
}
} // End of nested node class
// instance variables.
protected Node<V> head, tail;
protected long size;
// Create empty constructor
public SLinkedList () {
head = null;
tail = null;
size = 0;
} // end constructor
// Add Fist method to add node to list.
public void addFirst (Node<V> node) {
// set the tail only if this is the very first node
if (tail == null)
tail = node;
node.setNext (head); //refer to head
head = node;
// adjust size.
size++;
} // end addFirst method.
// Add new node after current node. Checks to see if at tail also.
public void addAfter (Node<V>currentNode, Node<V>newNode) {
if (currentNode == tail)
tail = newNode;
newNode.setNext (currentNode.getNext ());
currentNode.setNext (newNode);
// adjust size.
size++;
} // end addAfter method.
// Add new node after the tail.
public void addLast (Node<V> node) {
node.setNext (null);
tail.setNext (node);
tail = node;
size++;
} // end addLast method
// Removes first node.
public Node<V> removeFirst () {
if (head == null)
System.err.println("Error: Attempt to remove from an empty list");
// save the one to return.
Node<V> temp = head;
head = head.getNext ();
temp.setNext(null);
size--;
return temp;
} // end method removeFirst
// remove the node at the end of the list.
public Node<V> removeLast () {
// // declare local variables/objects
Node<V> nodeBefore;
Node<V> nodeToRemove;
// make sure we have something to remove
if (size == 0)
System.err.println("Error: Attempt to remove fron an empty list");
// traverse through the list, getting a reference to the node before
// the trailer. Since there is no previous reference.
nodeBefore = getFirst ();
// potential error ?? See an analysis and drawing that indicates the number of iterations
// 9/21/10. size - 2 to account for the head and tail nodes. We want to refer to the one before the
// tail.
for (int count = 0; count < size - 2; count++)
nodeBefore = nodeBefore.getNext ();
// save the last node
nodeToRemove = tail;
// now, do the pointer manipulation
nodeBefore.setNext (null);
tail = nodeBefore;
size--;
return nodeToRemove;
} // end method removeLast
// Remove known node from list. Traverses through the list.
public void remove (Node<V> nodeToRemove) {
// declare local variables/references
Node<V> nodeBefore, currentNode;
// is there something to remove.
if (size == 0)
System.err.println("Error: Attempt to remove fron an empty list");
// Start at beginning of list.
currentNode = getFirst ();
if (currentNode == nodeToRemove)
removeFirst ();
currentNode = getLast ();
if (currentNode == nodeToRemove)
removeLast ();
// Check last two nodes.
if (size - 2 > 0) {
nodeBefore = getFirst ();
currentNode = getFirst ().getNext ();
for (int count = 0; count < size - 2; count++) {
if (currentNode == nodeToRemove) {
// remove current node
nodeBefore.setNext (currentNode.getNext ());
size--;
break;
} // end if node found
// references
nodeBefore = currentNode;
currentNode = currentNode.getNext ();
} // end loop to process elements
} // end if size - 2 > 0
} // end method remove
// Get methods
public Node<V> getFirst () { return head; }
public Node<V> getLast () { return tail; }
public long getSize () { return size; }
}
Here is my output.
The Original High Scores [, (Rick, 234), (Juan, 777), (Craig, 465),
(Mike, 925), (Jeremy, 438), (Steve, 121), (Steve, 121), (Steve, 121)]
Scores after adding Tyler [, (Rick, 234), (Tyler, 895), (Juan, 777),
(Craig, 465), (Mike, 925), (Jeremy, 438), (Steve, 121), (Steve, 121),
(Steve, 121)]

The while loop while(currentNode != null) only executes once, because the condition inside will break if the current item is NOT null. So it basically always adds the new item just after the first item.
The logic in the method add is very very wrong.

deleteBack java program

I am doing some exercises on practice-it website. And there is a problem that I don't understand why I didn't pass
Write a method deleteBack that deletes the last value (the value at the back of the list) and returns the deleted value. If the list is empty, your method should throw a NoSuchElementException.
Assume that you are adding this method to the LinkedIntList class as defined below:
// A LinkedIntList object can be used to store a list of integers.
public class LinkedIntList {
private ListNode front; // node holding first value in list (null if empty)
private String name = "front"; // string to print for front of list
// Constructs an empty list.
public LinkedIntList() {
front = null;
}
// Constructs a list containing the given elements.
// For quick initialization via Practice-It test cases.
public LinkedIntList(int... elements) {
this("front", elements);
}
public LinkedIntList(String name, int... elements) {
this.name = name;
if (elements.length > 0) {
front = new ListNode(elements[0]);
ListNode current = front;
for (int i = 1; i < elements.length; i++) {
current.next = new ListNode(elements[i]);
current = current.next;
}
}
}
// Constructs a list containing the given front node.
// For quick initialization via Practice-It ListNode test cases.
private LinkedIntList(String name, ListNode front) {
this.name = name;
this.front = front;
}
// Appends the given value to the end of the list.
public void add(int value) {
if (front == null) {
front = new ListNode(value, front);
} else {
ListNode current = front;
while (current.next != null) {
current = current.next;
}
current.next = new ListNode(value);
}
}
// Inserts the given value at the given index in the list.
// Precondition: 0 <= index <= size
public void add(int index, int value) {
if (index == 0) {
front = new ListNode(value, front);
} else {
ListNode current = front;
for (int i = 0; i < index - 1; i++) {
current = current.next;
}
current.next = new ListNode(value, current.next);
}
}
public boolean equals(Object o) {
if (o instanceof LinkedIntList) {
LinkedIntList other = (LinkedIntList) o;
return toString().equals(other.toString()); // hackish
} else {
return false;
}
}
// Returns the integer at the given index in the list.
// Precondition: 0 <= index < size
public int get(int index) {
ListNode current = front;
for (int i = 0; i < index; i++) {
current = current.next;
}
return current.data;
}
// Removes the value at the given index from the list.
// Precondition: 0 <= index < size
public void remove(int index) {
if (index == 0) {
front = front.next;
} else {
ListNode current = front;
for (int i = 0; i < index - 1; i++) {
current = current.next;
}
current.next = current.next.next;
}
}
// Returns the number of elements in the list.
public int size() {
int count = 0;
ListNode current = front;
while (current != null) {
count++;
current = current.next;
}
return count;
}
// Returns a text representation of the list, giving
// indications as to the nodes and link structure of the list.
// Detects student bugs where the student has inserted a cycle
// into the list.
public String toFormattedString() {
ListNode.clearCycleData();
String result = this.name;
ListNode current = front;
boolean cycle = false;
while (current != null) {
result += " -> [" + current.data + "]";
if (current.cycle) {
result += " (cycle!)";
cycle = true;
break;
}
current = current.__gotoNext();
}
if (!cycle) {
result += " /";
}
return result;
}
// Returns a text representation of the list.
public String toString() {
return toFormattedString();
}
// ListNode is a class for storing a single node of a linked list. This
// node class is for a list of integer values.
// Most of the icky code is related to the task of figuring out
// if the student has accidentally created a cycle by pointing a later part of the list back to an earlier part.
public static class ListNode {
private static final List<ListNode> ALL_NODES = new ArrayList<ListNode>();
public static void clearCycleData() {
for (ListNode node : ALL_NODES) {
node.visited = false;
node.cycle = false;
}
}
public int data; // data stored in this node
public ListNode next; // link to next node in the list
public boolean visited; // has this node been seen yet?
public boolean cycle; // is there a cycle at this node?
// post: constructs a node with data 0 and null link
public ListNode() {
this(0, null);
}
// post: constructs a node with given data and null link
public ListNode(int data) {
this(data, null);
}
// post: constructs a node with given data and given link
public ListNode(int data, ListNode next) {
ALL_NODES.add(this);
this.data = data;
this.next = next;
this.visited = false;
this.cycle = false;
}
public ListNode __gotoNext() {
return __gotoNext(true);
}
public ListNode __gotoNext(boolean checkForCycle) {
if (checkForCycle) {
visited = true;
if (next != null) {
if (next.visited) {
// throw new IllegalStateException("cycle detected in list");
next.cycle = true;
}
next.visited = true;
}
}
return next;
}
}
// YOUR CODE GOES HERE
}
My work so far is this:
public int deleteBack(){
if(front==null){
throw new NoSuchElementException();
}else{
ListNode current = front;
while(current!=null){
current = current.next;
}
int i = current.data;
current = null;
return i;
}
}

Don't you want to iterate until the current.next is != null?
What you have now passes the entire list, and your last statements do nothing, since current is null already.

Think about the logic you have here
while(current!=null){
current = current.next;
}
When that loop exits, current == null, and then you try to access current's data. Does this point you in the right direction?

// This is the quick and dirty
//By Shewan
public int deleteBack(){
if(size()== 0){ throw new NoSuchElementException(); }
if(front==null){ throw new NoSuchElementException();
}else{
if(front.next == null){
int i = front.data;
front = null;
return i;
}
ListNode current = front.next;
ListNode prev= front;
while(current.next!=null){
prev = current;
current = current.next;
}
int i = current.data;
prev.next = null;
return i;
}
}