Skip to main content

Implement an algorithm to find nth to last element of a singly linked list

File:LinkedList.java
-------------------------------------------------------------------------------------
package org.developersbrain.solutions;

class Node<T>{
Node<T> nextNode;
T t;
int n;
Node(T t){
this.t=t;
n=0;
}
}

public class LinkedList<T> {
Node<T> head;
Node<T> tail;
int counter;

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

void add(T t){
Node<T> newN=new Node<T>(t);
counter++;
if(head==null && tail==null){
head=newN;
tail=newN;
head.n=counter;
}else{
tail.nextNode=newN;
tail=newN;
tail.n=counter;
}
}

void traverse(){
Node<T> trNode=head;
while(trNode!=null){
System.out.print(trNode.t.toString()+"-->");
trNode=trNode.nextNode;
}
System.out.println("List Ends");
}

void traverse(int n){
Node<T> trNode=head;
if(n>counter){
System.out.println("Oops! List is smaller than you think!");
return;
}

System.out.println("Printing elements from position:"+n);
while(trNode!=null){
if(n==trNode.n){
System.out.print(trNode.t.toString()+"-->");
n++;
}trNode=trNode.nextNode;
}
System.out.println("List Ends");
}


}

File:MainClass.java
------------------------------------------------------------------------------------
package org.developersbrain.solutions;

public class MainClass {

public static void main(String[] args) {
LinkedList<String> ll=new LinkedList<String>();
ll.add("Element 1");
ll.add("Element 2");
ll.add("Element 3");
ll.add("Element 4");
ll.add("Element 5");
ll.add("Element 6");
ll.add("Element 7");
ll.add("Element 8");
ll.add("Element 9");
ll.add("Element 10");
ll.add("Element 11");
ll.add("Element 12");
ll.add("Element 13");
ll.add("Element 14");
ll.add("Element 15");
ll.add("Element 16");
ll.add("Element 17");
ll.add("Element 18");
ll.add("Element 19");
ll.add("Element 20");
ll.add("Element 21");
ll.add("Element 22");
ll.add("Element 23");
ll.add("Element 24");
ll.add("Element 25");
ll.add("Element 26");
ll.add("Element 27");
ll.add("Element 28");
ll.add("Element 29");
ll.add("Element 30");
ll.add("Element 31");
ll.add("Element 32");
ll.add("Element 33");
ll.add("Element 34");
ll.add("Element 35");
ll.add("Element 36");
System.out.println("Case 1:");
System.out.println("-----------------------------------");
ll.traverse(15);
System.out.println();
System.out.println();
System.out.println("Case 2:");
System.out.println("-----------------------------------");
ll.traverse(45);
}

}

Output:
-----------------------------------------------------------------------------------
Case 1:
-----------------------------------
Printing elements from position:15
Element 15-->Element 16-->Element 17-->Element 18-->Element 19-->Element 20-->Element 21-->Element 22-->Element 23-->Element 24-->Element 25-->Element 26-->Element 27-->Element 28-->Element 29-->Element 30-->Element 31-->Element 32-->Element 33-->Element 34-->Element 35-->Element 36-->List Ends


Case 2:
-----------------------------------
Oops! List is smaller than you think!



Comments

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...

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 ; ...

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...