How to find middle node of LinkedList without using extra memory in java

To find the middle node of a LinkedList without using extra memory in Java, you can use the "tortoise and hare" algorithm. This algorithm uses two pointers, a slow pointer and a fast pointer. The slow pointer moves one step at a time, while the fast pointer moves two steps at a time. When the fast pointer reaches the end of the list, the slow pointer will be at the middle. Here's how you can implement it:

class Node {
    int data;
    Node next;

    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

public class LinkedList {
    Node head;

    // Function to add a new node at the end
    public void add(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
    }

    // Function to find the middle node
    public Node findMiddle() {
        if (head == null) {
            return null;
        }

        Node slowPointer = head;
        Node fastPointer = head;

        while (fastPointer != null && fastPointer.next != null) {
            slowPointer = slowPointer.next;
            fastPointer = fastPointer.next.next;
        }

        return slowPointer;
    }

    // Function to print the LinkedList
    public void printList() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        list.printList();

        Node middle = list.findMiddle();
        if (middle != null) {
            System.out.println("The middle element is: " + middle.data);
        } else {
            System.out.println("The list is empty.");
        }
    }
}

Explanation:
Node Class: This is a simple class representing a node in the linked list.
LinkedList Class: This class contains methods to add a node, find the middle node, and print the linked list.
add Method: This method adds a new node to the end of the linked list.
findMiddle Method: This method uses the tortoise and hare algorithm to find the middle node. If the list is empty, it returns null.
printList Method: This method prints all the elements of the linked list.
main Method: This is the entry point of the program, where we create a linked list, add elements to it, print the list, and find and print the middle element.

How to sort an HashMap based on value

 
 

import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class SortHashMapByValue {

	public static void main(String[] args) {

		HashMap<String,Integer> unsortMap = new HashMap<String, Integer>();
		unsortMap.put("Ram", 10);
		unsortMap.put("Syam", 50);
		unsortMap.put("Radhe", 5);
		unsortMap.put("Krishna", 80);
		unsortMap.put("Suneel", 20);
		
		System.out.println("Before sorting:");
		printMap(unsortMap);
        
		System.out.println("\n");
		System.out.println("Sorting sorting:");
		HashMap<String,Integer> sortedMap = (sortHashMap(unsortMap));
		printMap(sortedMap);
		
	}

	private static HashMap<String, Integer> sortHashMap(HashMap<String, Integer> unsortMap) {
		List<Entry<String, Integer>> list = new LinkedList<Map.Entry<String,Integer>>(unsortMap.entrySet());
		Collections.sort(list, new Comparator<Map.Entry<String,Integer>>() {

			@Override
			public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
				
				return o1.getValue().compareTo(o2.getValue());
			}
		});
		
		LinkedHashMap<String, Integer> sortedMap = new LinkedHashMap<String, Integer>();
		for (Entry<String, Integer> entry : list) {
			sortedMap.put(entry.getKey(), entry.getValue());
		}
		return sortedMap;
	}

	private static void printMap(HashMap<String, Integer> unsortMap) {
		
		for(Entry<String, Integer> entry : unsortMap.entrySet()) {
			
			System.out.println("The Key is :- "+entry.getKey()+" The Value is:- "+entry.getValue());
		}
	}

}

Output:- 
Before sorting:
The Key is :- Radhe The Value is:- 5
The Key is :- Krishna The Value is:- 80
The Key is :- Syam The Value is:- 50
The Key is :- Suneel The Value is:- 20
The Key is :- Ram The Value is:- 10


Sorting sorting:
The Key is :- Radhe The Value is:- 5
The Key is :- Ram The Value is:- 10
The Key is :- Suneel The Value is:- 20
The Key is :- Syam The Value is:- 50
The Key is :- Krishna The Value is:- 80


 

How to reverse linked list without using inbuild function or extra loop

  
import java.util.LinkedList;

public class LinkedListReversePractice {

	public static void main(String[] args) {

		LinkedList<Integer> numbers = new LinkedList<Integer>();
		numbers.add(1);
		numbers.add(2);
		numbers.add(3);
		numbers.add(4);
		numbers.add(5);
		
		System.out.println("LinkedList before reversion:- "+numbers);
		
		numbers = reverseLinkedList(numbers);
		System.out.println("LinkedList after reversion:- "+numbers);
		
	}

	private static LinkedList<Integer> reverseLinkedList(LinkedList<Integer> numbers) {
		
		for(int i = 0; i< numbers.size()/2; i++) {
			 
			int temp = numbers.get(i);
			numbers.set(i, numbers.get(numbers.size()-1-i));
			numbers.set(numbers.size()-1-i, temp);
			
		}
		return numbers;
	}
	
}

Output:- 
LinkedList before reversion:- [1, 2, 3, 4, 5]
LinkedList after reversion:- [5, 4, 3, 2, 1]

 

How to find prime numbers from 1 to 100

public class PrimeNumber1To100 {

	public static void main(String[] args) {

		System.out.println("Prime numbers from 1 to 100 are :");

		for(int i=1;i<=100;i++) {
			
			int counter=0;
			for(int num = i;num>=1;num--) {
				
				if(i%num == 0) {
					
					counter++;
				}
			}
			if(counter == 2) {
				System.out.print(i+" ");
			}
		}
	}

}

Output:- 
Prime numbers from 1 to 100 are :
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 

 

Least repeated Item in the Integer Array

  
  
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class LeastRepeatedNumber {

	public static void main(String[] args) {

		int[] array1 = {1,1,3,2,3,1,4,2,2};
		System.out.println("Least Repeated Number is : "+findLeastRepatedNumber(array1));

	}
	public static Integer findLeastRepatedNumber(int ...array) {
		Integer leastRepatedCount=0;
		Map<nteger,Integer> map = new HashMap<>();
		Integer leastRepeatedItem=null;
		for(int i:array) {

			if(map.containsKey(i)) {
				int counter = map.get(i)+1;
				map.put(i, counter);
			}else {
				map.put(i,1);
			}

		}

		for(Entry<Integer, Integer> entry : map.entrySet()) {

			int v = entry.getValue();
			int k = entry.getKey();
			if(v>1) {

				if(leastRepatedCount==0 || v<leastRepatedCount) {
					leastRepatedCount = v;
					leastRepeatedItem = k;
				}

			}

		}
		return leastRepeatedItem;
	}
}


Output:- 
 Least Repeated Number is : 3


 

Common elements in two sorted arrays

import java.util.ArrayList;
import java.util.Arrays;

public class CommonNumbers {

	public static void main(String[] args) {
          int[] array1A = {1, 3, 4, 6, 7, 9};
          int[] array2A = {1, 2, 4, 5, 9, 10};
          Integer[] com = common(array1A,array2A);
          for(int i : com) {
              System.out.println(i);
          }

	}

	public static Integer[] common(int array1[], int array2[]) {
		
		int p1=0,p2=0;
		ArrayList<Integer> list = new ArrayList<>();
		while(p1<array1.length && p2 < array2.length) {
			
			if(array1[p1]  == array2[p2]) {
				list.add(array1[p1]);
				p1++;
				p2++;
			}else if(array1[p1] > array2[p2]) {
				p2++;
			}else {
				p1++;
			}
		}
		Integer[] common = new Integer[list.size()];
		return list.toArray(common);
	}
}
Output:- 
1
4
9
  

How to find pair of two numbers that's multiply equals to Key

  

    import java.util.ArrayList;

    public class FindPair {

        public static void main(String[] args) {
            int arr[] = {1,2,4,6,3,5}; 
            int key = 20; 
            findPair(arr,key);


        }

        private static void findPair(int[] arr, int key) {
            ArrayList<Integer> numbers = new ArrayList<>();
            boolean status = false;
            for(int num : arr) {

                int anotherNumber = (key/num);
                if(numbers.contains(anotherNumber) && (anotherNumber*num) == key) {
                    status=true;
                    System.out.println("Pair Found: "+"( "+anotherNumber+", "+ num+" )"); 
                }
                numbers.add(num);
            }
            if(!status)
                System.out.print("No such pair"); 

        }

    }
Output:- 
 Pair Found:- (4,5)
  

Most Frequently Occurring Item in an Array

  
  import java.util.HashMap;
  import java.util.Map;

  public class MostOccuranceNumber {

      public static void main(String[] args) {

          int[] array1 = {1,2,4,1,3,6,1};
          System.out.println(mostOccurance(array1));

      }
      public static Integer mostOccurance(int ...array) {
          Integer mostCount=0;
          Map<Integer,Integer> map = new HashMap<>();
          Integer mostItem=null;
          for(int i:array) {

              if(map.containsKey(i)) {
                  int counter = map.get(i)+1;
                  map.put(i, counter);
              }else {
                  map.put(i,1);
              }
              if(map.get(i) > mostCount) {
                  mostCount = map.get(i);
                  mostItem = i;
              }
          }
          return mostItem;
      }
  }

Output:- 
 1
 

How to find middle element of LinkedList without using inbuilt method or extra loop

 
1) List Interface Implementation
 
  public interface List<T extends Comparable<T>> {

      public Node<T> getMiddleNode();
      public void insert(T data);
      public void remove(T data);
      public void traverse();
      public int size();
      public void reverse();
  }

 
2) Linked List's Node Implementation
 
 public class Node<T extends Comparable<T>> {

	private Node<T> nextNode;
	T data;
	
	public Node(T data){
		this.data = data;
	}
	
	public Node<T> getNextNode() {
		return nextNode;
	}
	public void setNextNode(Node<T> nextNode) {
		this.nextNode = nextNode;
	}
	public T getData() {
		return data;
	}
	public void setData(T data) {
		this.data = data;
	}

	@Override
	public String toString() {
		return data+"-> ";
	}
	
	
}


3) Linked List Implementation

public class LinkedList<T extends  Comparable<T>> implements List<T> {

	private Node<T> head;
	int sizeCounter=0;
	
	
	@Override
	public Node<T> getMiddleNode() { ==> Example to find middle node of LinkedList 
		Node<T> slow = head;
		Node<T> fast = head;
		while(fast.getNextNode() != null &&
        fast.getNextNode().getNextNode() != null) {
			slow = slow.getNextNode();
			fast = fast.getNextNode().getNextNode();
		}
		return slow;
	}
	@Override
	public void insert(T data) {
		sizeCounter++;
		if(head==null) {
			head = new Node<T>(data);			
		}else {
			insertBiginning(data);
		}
		
	}
	private void insertBiginning(T data) {
		Node<T> node = new Node<T>(data);
		node.setNextNode(head);
		head = node;
		
	}
	@Override
	public void remove(T data) {
		if(head == null) return;
		
		if(head.getData().compareTo(data) == 0) {
			head = head.getNextNode();
		}else {
			remove(data,head, head.getNextNode());
		}
		
	}
	private void remove(T data, Node<T> previousNode, Node<T> actualNode) {
		
		while(actualNode != null) {
			
			if(actualNode.getData().compareTo(data)==0) { ==> This is the reason we use generic type which extends Comparable
				sizeCounter--;
				previousNode.setNextNode(actualNode.getNextNode());
				actualNode=null;
				return;
			}
			previousNode = actualNode;
			actualNode = actualNode.getNextNode();
		}
	}
	@Override
	public void traverse() { ==> Example to traverse linked list 
r
		if(head==null) return;
		Node<T> actualNode = head;
		while(actualNode != null) {
			System.out.print(actualNode);
			actualNode = actualNode.getNextNode();
		}
		
	}
	@Override
	public int size() {
		return sizeCounter;
	}
	@Override
	public void reverse() { ==> Example to reverse LinkedList 
		
		Node<T> prev = null;
		Node<T> next = null;
		Node<T> current = head;
		
		while(current != null) {
			next = current.getNextNode();
			current.setNextNode(prev);
			prev = current;
			current = next;
			
		}
		head = prev;
	}
	
	
}


4) Linked List uses example

public class AppRunner {

	public static void main(String[] args) {
		LinkedList<String> names = new LinkedList<>();
		names.insert("narayan");
		names.insert("Pawan");
		names.insert("Karan");
		names.insert("Sonu");
		names.insert("Ram");
		
		names.traverse(); ==> Traversing Linked List
		System.out.println("");
		System.out.println("Middle node is :- "+names.getMiddleNode());==> Finding middle element without using extra loop
		
		
		names.reverse(); ==> Reversing linkedList without inbuilt function
		System.out.println("");
		names.traverse();
	}

}


5) Output:- 
Before Reverse:-  Tarun-> Nishant-> Gajendra-> Sonpal-> Ravi-> Anurag-> Narayan-> 
After ReversingNarayan-> Anurag-> Ravi-> Sonpal-> Gajendra-> Nishant-> Tarun-> 
Middle node is :- Sonpal->
 

What will be the output of given example

public class StringConcating {

	public static void main(String[] args) {
		String str ="Hello";
		String str2 = "Narayan";
		String str3 = "HelloNarayan";
		String str4 = str+str2;
		
		if(str3 == str4) {
			System.out.println("Match");
		}else {
			System.out.println("Not Match");
		}
	}

}


Output:-
Not Match


Now you may wordering bcoz both object have same value still not match
so reason behind of this is when we do any operation over string it
return new object that will store in heap memory so we can say that str4 store
in heap while str3 will store in string constant pool and can't change value
of it since string is immutable

How to reverse an Array without using extra memory

public class ReverseArrayWithoutExtraMemory {

	public static void main(String[] args) {
		int arr[] = {1,2,3,4,5,6};
		int swapArray[] = new ReverseArrayWithoutExtraMemory().swapArray(arr);
		for (int i : swapArray) {
			System.out.print(i+" ");
		}
	}

	public int[] swapArray(int[] arr) {
		int startIndex=0;
		
		int lastIndex= arr.length-1;
		while(lastIndex > startIndex) {
			
			swapItem(arr, startIndex, lastIndex);
			lastIndex--;
			startIndex++;
		}
		return arr;
	}

	public void swapItem(int[] arr, int startIndex, int lastIndex) {
		int temp = arr[startIndex];
		arr[startIndex] = arr[lastIndex];
		arr[lastIndex] = temp;
		
	}

}

Output:-
6 5 4 3 2 1

How to find biggest item in the array within constant time complexity

public class BiggestnumberInArray {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int arr[] = {1,8,10,40,30,60,50,0,-2}; 
		System.out.println("The biggest Item is : "+
        new BiggestnumberInArray().findBiggestItem(arr));
	}

	public int findBiggestItem(int arr[]) {
		int biggest=0;
		for (int i : arr) {
			
			if(biggest==0) {
				biggest=i;
			}
			if(biggest < i) {
				biggest = i;
			}
		}
		return biggest;
	}
}


Output:-
The biggest Item is : 60

How to find smallest item in the array within constant time complexity

	
    
public class SmallestItemIntoArray {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int arr[] = {1,8,10,40,30,60,50,0,-2}; 
        
		System.out.println("The smallest Item is : "+
        	new SmallestItemIntoArray().smallestItem(arr));
	}

	public int smallestItem(int arr[]) {
		int smallest=0;
		for (int i : arr) {
			
			if(smallest==0) {
				smallest=i;
			}
			if(smallest > i) {
				smallest = i;
			}
		}
		return smallest;
	}
}


Output:-
The smallest Item is : -2
    

Stack Implementation using Array Data structure

Stack Implementation

import java.util.Arrays;
public class Stack {

	private int count=0;
	private T[] data;
	
	Stack(){
		data = (T[]) new Object[1];
	}
	
	public int size() {
		return count;
	}
	public boolean isEmpty() {
		return count==0;
	}
	public void push(T newItem) {
		
		if(count==data.length) {
			resize(2*data.length);
		}
		data[count++] = newItem;
	}
	public T pop() {
		T item = data[--count];
		if(count>0 && count == (data.length/4)){
			resize(data.length/2);
		}
		return item;
	}
	public void resize(int newCapacity){
		T stackCopy[] = Arrays.copyOf(data, newCapacity);
		data = stackCopy;
	}
}



App Runner:-


public class StackApp {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Stack stack = new Stack();
		stack.push(10);
		stack.push(30);
		stack.push(4);
		stack.push(7);
		stack.push(14);
		
		while(!stack.isEmpty())
			System.out.println(stack.pop());
	}

}


Output:-
14
7
4
30
10

How to find pair of two numbers whose difference equivalent to given key less than N square time complexity

  
public class DifferencePair {

	public static void main(String[] args) {
		int arr[] = {1,8,10,40,30,60,50}; 
		int n = 10;  
		findPair(arr,n);

	}

	private static void findPair(int[] arr, int n) {
		ArrayList<Integer> numbers = new ArrayList<>();
		boolean status = false;
		for(int num : arr) {
			
			if(numbers.contains((num-n))){
				status=true;
				System.out.println("Pair Found: "+"( "+(num-n)+", "+ num+" )"); 
			}
			
			if (numbers.contains((num+n))) {
				status=true;
				System.out.println("Pair Found: "+"( "+(num+n)+", "+ num+" )"); 
			}

			numbers.add(num);
		}
		if(!status)
			System.out.print("No such pair"); 
	}

}

Output:-
Pair Found: ( 40, 30 )
Pair Found: ( 40, 50 )
Pair Found: ( 60, 50 )

How to find Pair of two sum element equivalent to given key less than N square time complexity

  
public class SumPair {

	public static void main(String[] args) {
		int arr[] = {5,7,8,3,1,4,6,9,2}; 
		int n = 12; 
		findPair(arr,n);

	}

	private static void findPair(int[] arr, int n) {
		ArrayList<Integer> numbers = new ArrayList<>();
		boolean status = false;
		for(int num : arr) {
			
			int anotherNumber = (n-num);
			if(numbers.contains(anotherNumber) && (anotherNumber+num) == n) {
				status=true;
				System.out.println("Pair Found: "+"( "+anotherNumber+", "+ num+" )"); 
			}
			numbers.add(num);
		}
		if(!status)
			System.out.print("No such pair");
	}

}

Output:- 

Pair Found: ( 5, 7 )
Pair Found: ( 8, 4 )
Pair Found: ( 3, 9 )

how to install cvs on debian

how to install cvs on debian

Install the cvs follow these steps:
1.install cvs and cvsd

#apt-get install cvs cvsd

When configuring cvsd I was asked which repositories to serve. I typed ‘/cvs’.
This means my repository will be available at cvs.myserver.com/cvs






2. initialize the repository

#cvs -d /var/lib/cvsd/cvs init

3. allow write access to repository

#chown cvsd:cvsd /var/lib/cvsd/cvs

4. allow history file to be written

#chown cvsd:cvsd /var/lib/cvsd/cvs/CVSROOT/history

5. add developer use account

#cvsd-passwd /var/lib/cvsd/cvs kk

6.allow developer to write to repository

#echo "kk" /var/lib/cvsd/cvs/writers

After you've done that, your CVS pserver is ready to go. Now, from a remote system (in our case it is running Debian), you can access the repository.


#export CVSROOT=:pserver:username@servername:/cvs
#cvs login





From this point on you can use the remote CVS repository just like a local repository. You just have to try and remember to logout when you are done working with CVS.
#cvs logout
Assuming that you have a project held in a directory on the local machine which you wish to import simply run:
#cd ~/project
#cvs -d :pserver:username@servername:/cvs import -m "first import" project username release
Once this is done you can move to a different directory and try to check it out:
#cvs -d /home/cvs/ checkout project
If that works then you are done.

how to install cvs on debian

how to install cvs on debian

Install the cvs follow these steps:
1.install cvs and cvsd

#apt-get install cvs cvsd

When configuring cvsd I was asked which repositories to serve. I typed ‘/cvs’.
This means my repository will be available at cvs.myserver.com/cvs






2. initialize the repository

#cvs -d /var/lib/cvsd/cvs init

3. allow write access to repository

#chown cvsd:cvsd /var/lib/cvsd/cvs

4. allow history file to be written

#chown cvsd:cvsd /var/lib/cvsd/cvs/CVSROOT/history

5. add developer use account

#cvsd-passwd /var/lib/cvsd/cvs kk

6.allow developer to write to repository

#echo "kk" /var/lib/cvsd/cvs/writers

After you've done that, your CVS pserver is ready to go. Now, from a remote system (in our case it is running Debian), you can access the repository.


#export CVSROOT=:pserver:username@servername:/cvs
#cvs login





From this point on you can use the remote CVS repository just like a local repository. You just have to try and remember to logout when you are done working with CVS.
#cvs logout
Assuming that you have a project held in a directory on the local machine which you wish to import simply run:
#cd ~/project
#cvs -d :pserver:username@servername:/cvs import -m "first import" project username release
Once this is done you can move to a different directory and try to check it out:
#cvs -d /home/cvs/ checkout project
If that works then you are done.

Number Validation In JavaScript

This Validation Allow only Number Input


http://www.cambiaresearch.com/c4/029c978b-aac5-472e-97a8-95b256f5febd/How-Can-I-Use-Javascript-to-Allow-Only-Numbers-to-Be-Entered-in-a-TextBox.aspx

JAVA TRAINNER

http://www.java-examples.com/