Question & Answer: I need help with the implementation of a linked list in Java that computes addition, subtraction, multiplication, d…..

//Node.java

package com.test;

public class Node
{
protected int data;
protected Node next, prev;

/* Constructor */
public Node()
{
next = null;
prev = null;
data = 0;
}
/* Constructor */
public Node(int d, Node n, Node p)
{
data = d;
next = n;
prev = p;
}
/* Function to set link to next node */
public void setLinkNext(Node n)
{
next = n;
}
/* Function to set link to previous node */
public void setLinkPrev(Node p)
{
prev = p;
}
/* Funtion to get link to next node */
public Node getLinkNext()
{
return next;
}
/* Function to get link to previous node */
public Node getLinkPrev()
{
return prev;
}
/* Function to set data to node */
public void setData(int d)
{
data = d;
}
/* Function to get data from node */
public int getData()
{
return data;
}
}

//DoublyLinkedList.java

package com.test;

import com.test.Node;

import java.util.Scanner;

/* Class Node */

/* Class linkedList */

class linkedList

{

protected Node start;

protected Node end ;

public int size;

public int carry=0;

private int data;

/* Constructor */

public linkedList()

{

start = null;

end = null;

size = 0;

}

/* Function to check if list is empty */

public boolean isEmpty()

{

return start == null;

}

/* Function to get size of list */

public int getSize()

{

return size;

}

/* Function to insert element at begining */

public void insertAtStart(int val)

{

Node nptr = new Node(val, null, null);

if(start == null)

{

start = nptr;

end = start;

}

else

{

start.setLinkPrev(nptr);

nptr.setLinkNext(start);

start = nptr;

}

size++;

}

/* Function to insert element at end */

public void insertAtEnd(int val)

{

Node nptr = new Node(val, null, null);

if(start == null)

{

start = nptr;

end = start;

}

else

{

nptr.setLinkPrev(end);

end.setLinkNext(nptr);

end = nptr;

}

size++;

}

/* Function to insert element at position */

public void insertAtPos(int val , int pos)

{

Node nptr = new Node(val, null, null);

if (pos == 1)

{

insertAtStart(val);

return;

}

Node ptr = start;

for (int i = 2; i <= size; i++)

{

if (i == pos)

{

Node tmp = ptr.getLinkNext();

ptr.setLinkNext(nptr);

nptr.setLinkPrev(ptr);

nptr.setLinkNext(tmp);

tmp.setLinkPrev(nptr);

}

ptr = ptr.getLinkNext();

}

size++ ;

}

/* Function to delete node at position */

public void deleteAtPos(int pos)

{

if (pos == 1)

{

if (size == 1)

{

start = null;

end = null;

size = 0;

return;

}

start = start.getLinkNext();

start.setLinkPrev(null);

size–;

return ;

}

if (pos == size)

{

end = end.getLinkPrev();

end.setLinkNext(null);

size– ;

}

Node ptr = start.getLinkNext();

for (int i = 2; i <= size; i++)

{

if (i == pos)

{

Node p = ptr.getLinkPrev();

Node n = ptr.getLinkNext();

p.setLinkNext(n);

n.setLinkPrev(p);

size– ;

return;

}

ptr = ptr.getLinkNext();

}

}

/* Function to display status of list */

public void display()

{

System.out.print(“nDoubly Linked List = “);

if (size == 0)

{

System.out.print(“emptyn”);

return;

}

if (start.getLinkNext() == null)

{

System.out.println(start.getData() );

return;

}

Node ptr = start;

System.out.print(start.getData()+ ” <-> “);

ptr = start.getLinkNext();

while (ptr.getLinkNext() != null)

{

System.out.print(ptr.getData()+ ” <-> “);

ptr = ptr.getLinkNext();

}

System.out.print(ptr.getData()+ “n”);

}

 

int ElementAtIndex(int i)

{

if(i >= size)

return -1;

else

{

Node ptr = start;

for(int idx=0;idx<i;idx++)

{

ptr = ptr.getLinkNext();

}

return ptr.getData();

}

}

}

/* Class DoublyLinkedList */

public class DoublyLinkedList

{

public static void main(String[] args)

{

Scanner scan = new Scanner(System.in);

/* Creating object of linkedList */

//Below is the operation on linked list that we can perform

linkedList list = new linkedList();

System.out.println(“Doubly Linked List Testn”);

char ch;

/* Perform list operations */

do

{

System.out.println(“nDoubly Linked List Operationsn”);

System.out.println(“1. insert at begining”);

System.out.println(“2. insert at end”);

System.out.println(“3. insert at position”);

System.out.println(“4. delete at position”);

System.out.println(“5. check empty”);

System.out.println(“6. get size”);

int choice = scan.nextInt();

switch (choice)

{

case 1 :

System.out.println(“Enter integer element to insert”);

list.insertAtStart( scan.nextInt() );

break;

case 2 :

System.out.println(“Enter integer element to insert”);

list.insertAtEnd( scan.nextInt() );

break;

case 3 :

System.out.println(“Enter integer element to insert”);

int num = scan.nextInt() ;

System.out.println(“Enter position”);

int pos = scan.nextInt() ;

if (pos < 1 || pos > list.getSize() )

System.out.println(“Invalid positionn”);

else

list.insertAtPos(num, pos);

break;

case 4 :

System.out.println(“Enter position”);

int p = scan.nextInt() ;

if (p < 1 || p > list.getSize() )

System.out.println(“Invalid positionn”);

else

list.deleteAtPos(p);

break;

case 5 :

System.out.println(“Empty status = “+ list.isEmpty());

break;

case 6 :

System.out.println(“Size = “+ list.getSize() +” n”);

break;

default :

System.out.println(“Wrong Entry n “);

break;

}

/* Display List */

list.display();

System.out.println(“nDo you want to continue (Type y or n) n”);

ch = scan.next().charAt(0);

} while (ch == ‘Y’|| ch == ‘y’);

 

//created below two list to perform arithmetic operation

linkedList list1 = new linkedList();

list1.insertAtEnd(2);

list1.insertAtEnd(1);

list1.insertAtEnd(4);

list1.insertAtEnd(5);

linkedList list2 = new linkedList();

list2.insertAtEnd(1);

list2.insertAtEnd(7);

list2.insertAtEnd(3);

list2.insertAtEnd(4);

 

double num1 = 0, num2=0;

 

for(int i=0;i<list1.size;i++)

{

num1 += list1.ElementAtIndex(i)*Math.pow(10, list1.size – i -1);

}

for(int i=0;i<list1.size;i++)

{

num2 += list2.ElementAtIndex(i)*Math.pow(10, list2.size – i -1);

}

 

System.out.println(num1 +” ” +num2);

 

System.out.println(“Sum of two list: “+ (double)(num1+num2));

System.out.println(“Subtraction of two list: “+ (double)(num1-num2));

System.out.println(“Multiplication of two list: “+ (double)(num1*num2));

System.out.println(“Division of two list: “+ (double)(num1/num2));

System.out.println(“reminder of two list: “+ (int)(num1%num2));

 

}

 

}

//output;

Doubly Linked List Test

Doubly Linked List Operations

1. insert at begining
2. insert at end
3. insert at position
4. delete at position
5. check empty
6. get size
1
Enter integer element to insert
1

Doubly Linked List = 1

Do you want to continue (Type y or n)

n
2145.0 1734.0
Sum of two list: 3879.0
Subtraction of two list: 411.0
Multiplication of two list: 3719430.0
Division of two list: 1.2370242214532872
reminder of two list: 411