linked list data structure in java - Wikitechy

Java Program to reverse a Linked List ?

Editor — Wed, 14 Jul 2021 00:03:25 +0000

Java Program to reverse a Linked List ?

A Linked list contains two things data and the address of the node each node is linked to the next node.
There can be two solution to reverse a linked list in java.
- Iterative
- Recursive

Iterative

Here we have three nodes i.e previousNode, currentNode and nextNode
When currentNode is starting node, then previousNode will be null
Assign currentNode.next to previousNode to reverse the link.
In each iteration move currentNode and previousNode by 1 node.

public static Node reverseLinkedList(Node currentNode)
	{
		// For first node, previousNode will be null
		Node previousNode=null;
		Node nextNode;
		while(currentNode!=null)
		{
			nextNode=currentNode.next;
			// reversing the link
			currentNode.next=previousNode;
			// moving currentNode and previousNode by 1 node
			previousNode=currentNode;
			currentNode=nextNode;
		}
		return previousNode;
	}

Sample Code in Java:

public class LinkedList{
 
	private Node head;
 
	private static class Node {
		private int value;
		private Node next;
 
		Node(int value) {
			this.value = value;
 
		}
	}
 
	public void addToTheLast(Node node) {
 
		if (head == null) {
			head = node;
		} else {
			Node temp = head;
			while (temp.next != null)
				temp = temp.next;
 
			temp.next = node;
		}
	}
 
 
	public void printList(Node head) {
		Node temp = head;
		while (temp != null) {
			System.out.format("%d ", temp.value);
			temp = temp.next;
		}
		System.out.println();
	}
 
	// Reverse linkedlist using this function 
	public static Node reverseLinkedList(Node currentNode)
	{
		// For first node, previousNode will be null
		Node previousNode=null;
		Node nextNode;
		while(currentNode!=null)
		{
			nextNode=currentNode.next;
			// reversing the link
			currentNode.next=previousNode;
			// moving currentNode and previousNode by 1 node
			previousNode=currentNode;
			currentNode=nextNode;
		}
		return previousNode;
	}
 
	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		// Creating a linked list
		Node head=new Node(5);
		list.addToTheLast(head);
		list.addToTheLast(new Node(6));
		list.addToTheLast(new Node(7));
		list.addToTheLast(new Node(1));
		list.addToTheLast(new Node(2));
 
		list.printList(head);
		//Reversing LinkedList
		Node reverseHead=reverseLinkedList(head);
		System.out.println("After reversing");
		list.printList(reverseHead);
 
	}
 
}

Output :

5 6 7 1 2 
After reversing
2 1 7 6 5

Recursive Method:

Divide the list in two parts – first node and rest of the linked list.
Call reverse for the rest of the linked list.
Link rest to first.
Fix head pointer

How to make linked list program for the given list ?

Editor — Tue, 13 Jul 2021 17:24:03 +0000

How to make linked list program for the given list ?

Linked List is a type of Linear Data Structure that is mostly used data structure after array, which allocates memory dynamically at run time that is it doesn’t require any size initialization as in case of array.
Linked List stores data in the forms of nodes, which is divided into two parts, first part stores the data and second part points to the next node by storing the address of that node.
We have first node which contains Data and Address to next node, and similarly second and third node forming a chain.

Syntax

To create code, pattern required is:

LinkedList<String> linkedList=new LinkedList<String>()

Sample Code in Java

import java.util.Iterator;

import java.util.LinkedList;					

public class LinkedListDemo 
{

  public static void main (String[] args) {

  LinkedList linkedList=new LinkedList();

  linkedList.add("java");

  linkedList.add("Is");

  linkedList.add("High");

  linkedList.add("Level");

  linkedList.add("Language");

  Iterator itr=linkedList.iterator();

  while(itr.hasNext())
  {

   System.out.print(itr.next());

   System.out.print("\t");

  }

 }

}

Output

java Is High Level Language

What is Linked List in Data Structure with example ?

Editor — Tue, 13 Jul 2021 15:28:48 +0000

What is Linked List in Data Structure with example ?

A linked list is a sequence of data structures, which are connected together through links.
Linked List is a sequence of links which contains objects. Each link contains a connection to another link. Linked list is the second most-used data structure after array.
- Link − Each link of a linked list can store a data called an element.
- Next − Each link of a linked list contains a link to the next link called Next.
- LinkedList − A Linked List contains the connection link to the first link called First.

A linked list consists of nodes where each node contains a data field and a reference(link) to the next node in the list.

Types of Linked Lists

Singly linked list
Doubly linked list
Circular linked list

Singly linked list

A singly linked list is Item navigation is forward only.

Doubly linked list

A doubly linked list is a list that has two references, one to the next node and another to previous node.

Circular linked list

Another important type of a linked list is called a circular linked list where last node of the list points back to the first node (or the head) of the list.

Doubly Circular linked list

Circular doubly linked list is a type of data structure in which a node contain pointers to its previous node as well as the next node.
Circular doubly linked list doesn’t contain NULL in any of the node.
The last node contains the address of the first node of the list. The first node also contain address of the last node in its previous pointer.

Sample Code:

#include
#include 
int main()
{
   struct node
   {
      int num;
      struct node *ptr;
   };
   typedef struct node NODE;
   NODE *head, *first, *temp=0;
   int count = 0;
   int choice = 1;
   first = 0;
   while(choice)
   {
      head =(NODE*) malloc(sizeof(NODE));
      printf("Enter the data item: ");
      scanf("%d", &head-> num);
      if(first != 0)
      {
         temp->ptr = head;temp = head;
      }
      else
      {
         first = temp = head;
      }
      fflush(stdin);
      printf("Do you want to continue(Type 0 or 1)?\n\n");
      scanf("%d", &choice);
   }
   temp->ptr = 0;
   temp = first; /* reset temp to the beginning*/
   printf("\n Status of the linked list is\n");
   while(temp!=0)
   {
      printf("%d=>", temp->num);
      count++;
      temp = temp -> ptr;
   }
   printf("NULL\n");
   printf("No. of nodes in the list = %d\n", count);
   return 0;
}

Output:

Enter the data item: 10
Do you want to continue ?
1
Enter the data item: 20
Do you want to continue?
1
Enter the data item: 30
Do you want to continue?
0
Status of the Linked List is
10=>20=>30=>NULL
No.of nodes in the list = 3

Advantages of Linked List

Linked list is dynamic in nature which allocates the memory when required.
In linked list, stack and queue can be easily executed.
It reduces the access time.
Insert and delete operation can be easily implemented in linked list.

Disadvantages of Linked List

Reverse traversing is difficult in linked list.
Linked list has to access each node sequentially; no element can be accessed randomly.
In linked list, the memory is wasted as pointer requires extra memory for storage.