//DoubleNode class class DoubleNode { String str; DoubleNode prev, next; DoubleN

Question

//DoubleNode class

class DoubleNode
{
String str;
DoubleNode prev, next;

DoubleNode(String str)
{
this.str = str;
prev = null;
next = null;
}

String getStr()
{
return str;
}

DoubleNode getNext()
{
return next;
}

void setNext(DoubleNode next)
{
this.next = next;
}

DoubleNode getPrev()
{
return prev;
}

void setPrev(DoubleNode prev)
{
this.prev = prev;
}
}

//LinkList class
class DoublyLinkedList
{
DoubleNode head, tail;

DoublyLinkedList()
{
head = null;
tail = null;
}

DoubleNode getHead()
{
return head;
}

DoubleNode getTail()
{
return tail;
}

void addFirst(String s)
{
DoubleNode node = new DoubleNode(s);
if (head == null)
tail = node;
else
head.setPrev(node);
node.setNext(head);
head = node;
}

void addLast(String s)
{
DoubleNode node = new DoubleNode(s);
if (head == null)
head = node;
else
tail.setNext(node);
node.setPrev(tail);
tail = node;
}

void printList()
{
System.out.print("The list: ");
DoubleNode node = head;
while (node != null)
{
System.out.print(node.getStr() + " ");
node = node.getNext();
}
System.out.println();
}

void printListReverse()
{
System.out.print("The list in reverse: ");
DoubleNode node = tail;
while (node != null)
{
System.out.print(node.getStr() + " ");
node = node.getPrev();
}
System.out.println();
}

DoubleNode search(String s)
{
DoubleNode node = head;
while (node != null && !node.getStr().equals(s))
{
node = node.getNext();
}
return node;
}

DoubleNode getElement(int index)
{
DoubleNode node = head;
int pos = 0;
while (node != null && pos < index)
{
node = node.getNext();
pos++;
}
return node;
}

void insert(DoubleNode node, String newElem) // insert after that node
// if node=null --> insert as first element
{
DoubleNode newNode = new DoubleNode(newElem);
if (node == null)
addFirst(newElem);
else
{
DoubleNode nextNode = node.getNext();
newNode.setNext(nextNode);
node.setNext(newNode);
newNode.setPrev(node);
if (nextNode == null) // or node == tail
tail = newNode;
else
nextNode.setPrev(newNode);
  
}
}

void remove(DoubleNode node)
{
DoubleNode prev = node.getPrev();
DoubleNode next = node.getNext();
  
if (head == tail) // one element
{
head = null;
tail = null;
}
else if (head == node) // remove first element
{
next.setPrev(null);
head = next;
}
else if (tail == node) // remove last element
{
prev.setNext(null);
tail = prev;
}
else
{
prev.setNext(next);
next.setPrev(prev);
}
}

// Creating swapping method
public void swap(DoubleNode x,DoubleNode y)
{
// Declaring temp node and swapping

DoubleNode previousNodeX = x.getPrev();
DoubleNode nextNodeX = x.getNext();
DoubleNode previousNodeY = y.getPrev();
DoubleNode nextNodeY = y.getNext();
// handling null pointer exception
if((x.getPrev()== null)&& (y.getNext()== null)&&(x.getNext() != y))
{
  
y.setPrev(previousNodeX);
y.setNext(nextNodeX);
nextNodeX.setPrev(y);
x.setPrev(previousNodeY);
x.setNext(nextNodeY);
previousNodeY.setNext(x);
head = y;
tail = x;  
}
  
else if ((x.getPrev()== null) && (x.getNext() == y))
{
y.setPrev(previousNodeX);
nextNodeY.setPrev(x);
x.setNext(nextNodeY);
x.setPrev(y);
y.setNext(x);
head = y;
}
else if ((y.getNext()== null) && (x.getNext() == y))
{
previousNodeX.setNext(y);
y.setPrev(previousNodeX);
x.setNext(nextNodeY);
x.setPrev(y);
y.setNext(x);
tail = x;
}
else if ((y.getNext()== null) && (x.getNext() != y))
{
  
y.setPrev(previousNodeX);
y.setNext(nextNodeX);
previousNodeX.setNext(y);
nextNodeX.setPrev(y);
x.setPrev(previousNodeY);
x.setNext(nextNodeY);
previousNodeY.setNext(x);
tail = x;
}

else if ((x.getPrev()== null) && (x.getNext() != y))
{
  
y.setPrev(previousNodeX);
y.setNext(nextNodeX);
nextNodeX.setPrev(y);
x.setPrev(previousNodeY);
x.setNext(nextNodeY);
nextNodeY.setPrev(x);
previousNodeY.setNext(x);
head = y;
}
  
  

else if ((x.getPrev()!= null)&& (y.getNext()!= null)&& (x.getNext() == y) )
{
previousNodeX.setNext(y);
y.setPrev(previousNodeX);
nextNodeY.setPrev(x);
x.setNext(nextNodeY);
x.setPrev(y);
y.setNext(x);
}
else if ((x.getPrev()!= null)&& (y.getNext()!= null)&& (x.getNext() != y))
{
y.setPrev(previousNodeX);
y.setNext(nextNodeX);
nextNodeX.setPrev(y);
previousNodeX.setNext(y);
x.setPrev(previousNodeY);
x.setNext(nextNodeY);
nextNodeY.setPrev(x);
previousNodeY.setNext(x);
}

}

//Creating the sort method

public void sort()
{
//DoubleNode newHead = new DoubleNode(head.getStr());
DoubleNode pointer = head.next;
pointer.setPrev(head.next.getPrev());
pointer.setNext(head.next.getNext());
while(pointer != null)
{
DoubleNode innerPointer = head;
//System.out.println(head.str);
innerPointer.setPrev(head.getPrev());
innerPointer.setNext(head.getNext());
DoubleNode next = pointer.getNext();

if((innerPointer.getStr()).compareTo((pointer.getStr()))>0)
{
this.swap(innerPointer,pointer );
}
else
{
while((innerPointer.getStr()).equalsIgnoreCase(pointer.getStr())== false )
{
System.out.println("inner pointer "+innerPointer.getStr());
System.out.println("pointer "+pointer.getStr());
if((innerPointer.getStr()).compareTo((pointer.getStr()))>0)
{
this.swap(innerPointer, pointer);
}

innerPointer = innerPointer.next;



// System.out.println(innerPointer.getStr());
}
//System.out.println(pointer.getStr());
}
pointer = next;
}

}

}

//Main class calling sort

public class Assignment6Q1
{
public static void main(String[] args)
{
DoublyLinkedList list = new DoublyLinkedList();

list.addFirst("Orange");
list.addFirst("Grape");
list.addFirst("Banana");
list.addFirst("Kiwi");
list.addFirst("Apple");
list.addFirst("Pear");
list.printList();
list.swap(list.head, list.head.next);
list.sort();
list.printList();
list.printListReverse();
}
  
}

Please help with the Null pointer error,Here I am trying to write an insertion sort method but for some reason my code is giving me nullPointerException from :-

at assignment.pkg6q1.DoublyLinkedList.swap(DoublyLinkedList.java:219)

at assignment.pkg6q1.DoublyLinkedList.sort(DoublyLinkedList.java:257)

at assignment.pkg6q1.Assignment6Q1.main(Assignment6Q1.java:18)

BUILD FAILED (total time: 0 seconds)

Explanation / Answer

I changed the logic in swap() method. Instead of trying to keep the next, prev nodes, its easy if we simply keep the pointers as is and only swap the data part. This keeps the logic simple.
The modified code is given below along with output. Hope it helps. If it did, request you to please rate the answer. thank you.
To indent code in eclipse , select code by pressing ctrl+a and then indent using ctrl+i

//DoubleNode class
class DoubleNode
{
String str;
DoubleNode prev, next;
DoubleNode(String str)
{
this.str = str;
prev = null;
next = null;
}
String getStr()
{
return str;
}
DoubleNode getNext()
{
return next;
}
void setNext(DoubleNode next)
{
this.next = next;
}
DoubleNode getPrev()
{
return prev;
}
void setPrev(DoubleNode prev)
{
this.prev = prev;
}
}
//LinkList class
class DoublyLinkedList
{
DoubleNode head, tail;
DoublyLinkedList()
{
head = null;
tail = null;
}
DoubleNode getHead()
{
return head;
}
DoubleNode getTail()
{
return tail;
}
void addFirst(String s)
{
DoubleNode node = new DoubleNode(s);
if (head == null)
tail = node;
else
head.setPrev(node);
node.setNext(head);
head = node;
}
void addLast(String s)
{
DoubleNode node = new DoubleNode(s);
if (head == null)
head = node;
else
tail.setNext(node);
node.setPrev(tail);
tail = node;
}
void printList()
{
System.out.print("The list: ");
DoubleNode node = head;
while (node != null)
{
System.out.print(node.getStr() + " ");
node = node.getNext();
}
System.out.println();
}
void printListReverse()
{
System.out.print("The list in reverse: ");
DoubleNode node = tail;
while (node != null)
{
System.out.print(node.getStr() + " ");
node = node.getPrev();
}
System.out.println();
}
DoubleNode search(String s)
{
DoubleNode node = head;
while (node != null && !node.getStr().equals(s))
{
node = node.getNext();
}
return node;
}
DoubleNode getElement(int index)
{
DoubleNode node = head;
int pos = 0;
while (node != null && pos < index)
{
node = node.getNext();
pos++;
}
return node;
}
void insert(DoubleNode node, String newElem) // insert after that node
// if node=null --> insert as first element
{
DoubleNode newNode = new DoubleNode(newElem);
if (node == null)
addFirst(newElem);
else
{
DoubleNode nextNode = node.getNext();
newNode.setNext(nextNode);
node.setNext(newNode);
newNode.setPrev(node);
if (nextNode == null) // or node == tail
tail = newNode;
else
nextNode.setPrev(newNode);
}
}
void remove(DoubleNode node)
{
DoubleNode prev = node.getPrev();
DoubleNode next = node.getNext();
if (head == tail) // one element
{
head = null;
tail = null;
}
else if (head == node) // remove first element
{
next.setPrev(null);
head = next;
}
else if (tail == node) // remove last element
{
prev.setNext(null);
tail = prev;
}
else
{
prev.setNext(next);
next.setPrev(prev);
}
}
// Creating swapping method
public void swap(DoubleNode x,DoubleNode y)
{
String s = x.str;
x.str = y.str;
y.str = s;
}
//Creating the sort method
public void sort()
{
//DoubleNode newHead = new DoubleNode(head.getStr());
DoubleNode pointer = head.next;
pointer.setPrev(head.next.getPrev());
pointer.setNext(head.next.getNext());
while(pointer != null)
{
DoubleNode innerPointer = head;
//System.out.println(head.str);
innerPointer.setPrev(head.getPrev());
innerPointer.setNext(head.getNext());
DoubleNode next = pointer.getNext();
if((innerPointer.getStr()).compareTo((pointer.getStr()))>0)
{
this.swap(innerPointer,pointer );
}
else
{
while((innerPointer.getStr()).equalsIgnoreCase(pointer.getStr())== false )
{
System.out.println("inner pointer "+innerPointer.getStr());
System.out.println("pointer "+pointer.getStr());
if((innerPointer.getStr()).compareTo((pointer.getStr()))>0)
{
this.swap(innerPointer, pointer);
}
innerPointer = innerPointer.next;


// System.out.println(innerPointer.getStr());
}
//System.out.println(pointer.getStr());
}
pointer = next;
}
}
}
//Main class calling sort
public class Assignment6Q1
{
public static void main(String[] args)
{
DoublyLinkedList list = new DoublyLinkedList();
list.addFirst("Orange");
list.addFirst("Grape");
list.addFirst("Banana");
list.addFirst("Kiwi");
list.addFirst("Apple");
list.addFirst("Pear");
list.printList();
list.swap(list.head, list.head.next);
list.sort();
list.printList();
list.printListReverse();
}
}

output
======
The list: Pear Apple Kiwi Banana Grape Orange
inner pointer Apple
pointer Pear
inner pointer Apple
pointer Kiwi
inner pointer Pear
pointer Kiwi
inner pointer Apple
pointer Banana
inner pointer Kiwi
pointer Banana
inner pointer Pear
pointer Kiwi
inner pointer Apple
pointer Grape
inner pointer Banana
pointer Grape
inner pointer Kiwi
pointer Grape
inner pointer Pear
pointer Kiwi
inner pointer Apple
pointer Orange
inner pointer Banana
pointer Orange
inner pointer Grape
pointer Orange
inner pointer Kiwi
pointer Orange
inner pointer Pear
pointer Orange
The list: Apple Banana Grape Kiwi Orange Pear
The list in reverse: Pear Orange Kiwi Grape Banana Apple

Related Questions

Navigate

• Browse (All)
• Browse #
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.