package DataStructures.HashMap.Hashing;

/*

* this is algo which implies common mathematical set theory concept

* called intersection in which result is common values of both the sets

* here metaphor of sets is HashMap

Test Case:

Scanner scn=new Scanner(System.in);

int len =scn.nextInt();

int arr[]=new int[len];

int arr2[]=new int[len];

for(int i=0;i<2*len;i++) {

if(i<len)

arr[i]=scn.nextInt();

if(i>=len) {

arr2[i-len]=scn.nextInt();

}

}

System.out.println(Main(arr,arr2));

*/

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Map;

import java.util.Scanner;

import java.util.Set;

public class Intersection {

public static ArrayList Main(int arr[],int arr2[]) {

HashMap<Integer,Integer> hmap=new HashMap<>();

HashMap<Integer,Integer> hmap2=new HashMap<>();

for(int i=0;i<arr.length;i++) {

if(hmap.containsKey(arr[i])) {

int val=hmap.get(arr[i]);

hmap.put(arr[i],val+1);

}else

hmap.put(arr[i],1);

}

ArrayList<Integer> res=new ArrayList<>();

for(int i=0;i<arr2.length;i++) {

if(hmap.containsKey(arr2[i])&&hmap.get(arr2[i])>0) {

int val=hmap.get(arr2[i]);

hmap.put(arr2[i],val-1);

res.add(arr2[i]);

}

}

return res;

}

public Intersection() {

}

}

package DataStructures.Lists;

/*

* This class implements a SinglyLinked List.

* A linked list is similar to an array, it hold values.

* However, links in a linked list do not have indexes. With

* a linked list you do not need to predetermine it's size as

* it grows and shrinks as it is edited.

*it has functions called mid that gives node at mid

* in addn to linked list there is algo that

* construct a linked list with alternate sums of linked list

* and added to new one and add mid value

* i.e sum of first and last value of inital list

Test Case:

LinkedList LL1 = new LinkedList();

Scanner scn=new Scanner(System.in);

int numNodes=scn.nextInt();

for(int i=0;i<2*numNodes;i++) {

LL1.addLast(scn.nextInt());

}

LL1.display();

LinkedList LL2=new LinkedList();

LL2.formLL2(LL1);

LL2.display();

LinkedList LL3=new LinkedList();

LL3.formLL3(LL1);

LL3.display();

Node MID=LL1.midValue();

System.out.println(MID.data);

LinkedList updLL1=new LinkedList();

updLL1.formRes(LL1,LL2,LL3,MID);

updLL1.display();

updLL1.Size();

*/

import java.util.*;

import java.lang.*;

import java.io.*;

class LinkedList {

private class Node{

int data;

Node next;

Node(int data) {

this.data = data;

this.next = null;

}

}

public Node head = null;

public Node tail = null;

private int size=0;

public void addLast(int data) {

Node newNode = new Node(data);

if(this.head == null) {

this.head = newNode;

this.tail = newNode;

this.size++;

}

else {

this.tail.next = newNode;

this.tail = newNode;

this.size++;

}

}

public void display() {

Node current = this.head;

if(this.head == null) {

return;

}

while(current != null) {

System.out.print(current.data + " ");

current = current.next;

}

System.out.println();

}

public void formLL2(LinkedList LL1) {

Node current=LL1.head;

while(current.next!=null&&current.next.next!=null) {

int sum=current.data+current.next.next.data;

this.addLast(sum);

current=current.next.next;

}

}

public void formLL3(LinkedList LL1) {

Node current=LL1.head.next;

while(current.next!=null&&current.next.next!=null) {

int sum=current.data+current.next.next.data;

this.addLast(sum);

current=current.next.next;

}

}

public Node mid() {

Node slow=this.head;

Node fast=this.head;

while(fast.next!=null && fast.next.next!=null) {

slow=slow.next;

fast=fast.next.next;

}

return slow;

}

public Node midValue() {

int sum=this.head.data+this.tail.data;

Node mid=new Node(sum);

return mid;

}

public void formRes(LinkedList LL1,LinkedList LL2,LinkedList LL3,Node MID) {

Node LL1mid=LL1.mid();

Node currentLL1=LL1.head;

Node currentLL2=LL2.head;

Node currentLL3=LL3.head;

while(currentLL1!=null) {

this.addLast(currentLL1.data);

if(currentLL2!=null) {

this.addLast(currentLL2.data);

currentLL2=currentLL2.next;

}else if(currentLL1.equals(LL1mid)) {

this.addLast(MID.data);

}

else if(currentLL2==null&&currentLL3!=null) {

this.addLast(currentLL3.data);

currentLL3=currentLL3.next;

}

currentLL1=currentLL1.next;

}

}

public void Size() {

System.out.println(this.size);

}

}