Skip to main content

Doubly Linked List Implementation in Java


File: LinkedList.java
------------------------------------------------------------------------------------------------

package org.developersbrain.solutions;

class Block<T>{
Block<T> prevNode;
Block<T> nextNode;
T t;
Block(T t){
this.t = t;
prevNode=null;
nextNode=null;
}
}

public class LinkedList<T> {
Block<T> tail;
Block<T> head;

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

void add(T t){
Block<T> newBlock=new Block<T>(t);
if(head==null){
head=newBlock;
tail=newBlock;
}else{
if(tail.prevNode==null){
head=newBlock;
head.nextNode=tail;
tail.prevNode=head;
}else{
newBlock.nextNode=head;
head.prevNode=newBlock;
head=newBlock;
}
}
}

void deleteNode(T t){
Block<T> nodes=head;
while(nodes!=null){
if(nodes.t.equals(t)){
if(nodes.prevNode==null){
head=nodes.nextNode;
head.prevNode=null;
}else if(nodes.nextNode==null){
tail=nodes.prevNode;
tail.nextNode=null;
}else{
nodes.prevNode.nextNode=nodes.nextNode;
nodes.nextNode.prevNode=nodes.prevNode;
}
}
nodes=nodes.nextNode;
}
}

void traverseFromHead(){
Block<T> nodes=head;
while(nodes!=null){
System.out.println(nodes.t);
nodes=nodes.nextNode;
}
}

void traverseFromTail(){
Block<T> nodes=tail;
while(nodes!=null){
System.out.println(nodes.t);
nodes=nodes.prevNode;
}
}


}


File: MainClass.java
------------------------------------------------------------------------------------------------

package org.developersbrain.solutions;

import java.io.IOException;

public class MainClass {

public static void main(String[] args) throws IOException{
LinkedList<Integer> ll=new LinkedList<Integer>();
ll.add(10);
ll.add(20);
ll.add(50);
ll.add(100);
ll.add(150);
System.out.println("Doubly Linked List-Traverse From Head");
System.out.println("---------------------------------------");
ll.traverseFromHead();
System.out.println();
System.out.println("Doubly Linked List-Traverse From Tail");
System.out.println("---------------------------------------");
ll.traverseFromTail();
System.out.println();
System.out.println("Remove element from list - Value: 10");
System.out.println("---------------------------------------");
System.out.println();
ll.deleteNode(10);
System.out.println("After Removing element from List-Traverse From Head");
System.out.println("---------------------------------------");
ll.traverseFromHead();
}
}

Output:
-----------------------------------------------------------------------------

Doubly Linked List-Traverse From Head
---------------------------------------
150
100
50
20
10

Doubly Linked List-Traverse From Tail
---------------------------------------
10
20
50
100
150

Remove element from list - Value: 10
---------------------------------------

After Removing element from List-Traverse From Head
---------------------------------------
150
100
50
20

Comments

Post a Comment

Popular posts from this blog

CODILITY: Determine whether given string of parentheses is properly nested.

Task description A string S consisting of N characters is called  properly nested  if: S is empty; S has the form " (U) " where U is a properly nested string; S has the form " VW " where V and W are properly nested strings. For example, string " (()(())()) " is properly nested but string " ()) " isn't. Write a function: class Solution { public int solution(String S); } that, given a string S consisting of N characters, returns 1 if string S is properly nested and 0 otherwise. For example, given S = " (()(())()) ", the function should return 1 and given S = " ()) ", the function should return 0, as explained above. Assume that: N is an integer within the range [ 0 .. 1,000,000 ]; string S consists only of the characters " ( " and/or " ) ". Complexity: expected worst-case time complexity is O(N); expected worst-case space complexity is O(1) (not counting the storage requi...
1 comment
Read more

Distinct: Compute number of distinct values in an array.

Task description Write a function class Solution { public int solution(int[] A); } that, given a zero-indexed array A consisting of N integers, returns the number of distinct values in array A. Assume that: N is an integer within the range [ 0 .. 100,000 ]; each element of array A is an integer within the range [ −1,000,000 .. 1,000,000 ]. For example, given array A consisting of six elements such that: A[0] = 2 A[1] = 1 A[2] = 1 A[3] = 2 A[4] = 3 A[5] = 1 the function should return 3, because there are 3 distinct values appearing in array A, namely 1, 2 and 3. Complexity: expected worst-case time complexity is O(N*log(N)); expected worst-case space complexity is O(N), beyond input storage (not counting the storage required for input arguments). Elements of input arrays can be modified. class Solution { public int solution ( int [] A) { // write your code in Java SE 8 int len=A.length; int count= 1 ; ...
1 comment
Read more

change directory (cd) function for an abstract file system ( Java Implementation )

Write a function that provides change directory (cd) function for an abstract file system. Notes: Root path is '/'. Path separator is '/'. Parent directory is addressable as "..". Directory names consist only of English alphabet letters (A-Z and a-z). For example, new Path("/a/b/c/d").cd("../x").getPath() should return "/a/b/c/x". Note: The evaluation environment uses '\' as the path separator. public class Path {     private String path;     public Path(String path) {         this.path = path;     }     public String getPath() {         return path;     }     public Path cd(String newPath) {         //throw new UnsupportedOperationException("Waiting to be implemented."); String[] newP=newPath.split("/");     String[] oldP=path.split("/");     int lnCount=0;     for(String str:newP){     if(st...
6 comments
Read more