Doubly Linked List Is there a way to further modify/simplify/improve this program? I was thinking of maybe changing how...

Question

Question

Doubly Linked List Is there a way to further modify/simplify/improve this program? I was thinking of maybe changing how...

Doubly Linked List

Is there a way to further modify/simplify/improve this program? I was thinking of maybe changing how to get size. I'm not sure.

```
import java.util.Scanner;
```
```
 
```
```
/*  Class Node  */
```
```
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;
```
```
    }
```
```
}
```
```
 
```
```
/* Class linkedList */
```
```
class linkedList
```
```
{
```
```
    protected Node start;
```
```
    protected Node end ;
```
```
    public int size;
```
```
 
```
```
    /* 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("empty\n");

```
            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");

```
    }
```
```
}
```
```
 
```
```
/* Class DoublyLinkedList */
```
```
public class DoublyLinkedList
```
```
{    
```

    public static void main(String[] args)

```
    {            
```

        Scanner scan = new Scanner(System.in);

        /* Creating object of linkedList */

        linkedList list = new linkedList();

        System.out.println("Doubly Linked List Test\n");

```
        char ch;
```
```
        /*  Perform list operations  */
```
```
        do
```
```
        {
```

            System.out.println("\nDoubly Linked List Operations\n");

            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 position\n");

```
                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 position\n");

```
                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');

```
    }
```
```
}
```

Add a comment Improve this question Transcribed image text

Answer 1

Doubly Linked List Is there a way to further modify/simplify/improve this program? I was thinking of maybe changing how...

Homework Answers

Request Answer!

Add Answer to:
Doubly Linked List Is there a way to further modify/simplify/improve this program? I was thinking of maybe changing how...

Post as a guest

Earn Coins

Doubly Linked List The assignment is to modify the below code in any way (like changing the method of a function). Time...

Q) Modify the class Linked List below to make it a Doubly Linked List. Name your...

Programming in C: I am trying to modify this linked list to be doubly linked list....

C++ - I have a doubly linked list, but I haven't been able to get the...

My Question is: I have to modify this program, even a small modification is fine. Can...

n JAVA, students will create a linked list structure that will be used to support a...

BELOW IS THE CODE I ALREADY HAVE Linked List - Delete Modify Lab 5 and include...

C programming A linked list is a linear data structure that allows us to add and remove items fro...

iImplement a Singly Linked List detectLoop in Java, it would check whether the linked list contains...

Doubly Linked List Is there a way to further modify/simplify/improve this program? I was thinking of maybe changing how...

Homework Answers

Request Answer!

Add Answer to: Doubly Linked List Is there a way to further modify/simplify/improve this program? I was thinking of maybe changing how...

Post as a guest

Earn Coins

Add Answer to:
Doubly Linked List Is there a way to further modify/simplify/improve this program? I was thinking of maybe changing how...