javacpp

import java.util.* ; //Longest Prefix Which Is Also Suffix Which Is Used To Found a Pattern Through Avoid Repeated Characters in Given String. We Will Discuss KMP ALGORITHM TO Find A Pattern In Given String Latter. class lbs{ public static void main( String [] args){ Scanner in= new Scanner(System.in); //Get Input From User String s=in.nextLine(); //Convert String Into Char Array char [] ch=s.toCharArray(); int n=s.length(); int [] lbsArr= new int [n]; int j= 0 ,i= 1 ; lbsArr[ 0 ]= 0 ; //LPS ARRAY ALGORITHM /* i=1; j=0; string s="aaab" while i<n if s[i]==s[j]: lpsArr[i]=j; j=j+1 i=i+1 else: if j==0: lbsArr[j]=0 i=i+1 else:

 Inheritance is a future of oops(Object Oriented Programming).it Used To Share The Properties of Class or a class drive from another one class is Called Inheritance. in Java Programming "extends" Keyword is used to inherit the class. Syntax: class A{ //member variables and function } class B extends class A { //member variables and function } example, class A{ void superclass() { System.out.println("super class"); } } class B extends class A { public static void main() { B b=new B(); b.superclass(); } } From The Above Java Programming Contains Two Classes Named As "A" and "B".class A contains a Member Method Named as "superclass()" and class B contains main method.then class B is Inherit(Extends) From class A.So We are call The method superclass from class B.

 Array [5][3][4][10] ->values [0][1][2][3] ->index Linked List -Head -Tail -Middle /* [10|pointer]->[20|pointer]->[30|pointer] */ Stack -Push -Pop -Top -Peak /* [ 20 ] <--Push Or Pop From One Side [ 15 ] [ 10 ] [ 5  ] */ Que -Push -Enque -Deque /* Pop From Another Side <--[5][10][15][20] <--Push from One Side */ Tree -Root -Left -Right /*    root /    \        /      \      Left Right     / \           \    /     \            \ Left right     Right Traversal 1.PreOrder(Root,Left,Right) Regressive(root): if(root!=null) print(root.data) Regressive(root.left) Regressive(root.right) 2.InOrder(Left,Root,Right) Regressive(root): if(root!=null) Regressive(root.left) print(root.data) Regressive(root.right) 3.PostOrder(Left,Right,Root) Regressive(root): if(root!=null) Regressive(root.left) Regr

1.Factorial of Given Number Using Java. import java.util.*;  class factorial{ public static int fact( int n){ if (n< 3 ){ return 1 ; } else { return fact(n- 1 )+fact(n- 2 ); } } public static void main( String [] args){          Scanner in=new Scanner(System.in);          int n=in.nextInt(); System.out.println(fact( n )); } } output: 6 8 2.staireCase Using Java Programming. class staireCase{ public static void main( String [] args){ int n= 5 ; for ( int i= 1 ;i<=n;i++){ for ( int j= 0 ;j<n;j++){ if (j>=n-i) { System.out.print( "#" ); } else { System.out.print( " " ); } } System.out.println(); } } } output: # ## ### #### ##### 3.Linear Search //o(n)

  /* Stack Is a Linear Data Structure.FIFO(First In First Out) or LIFO(Last In First Out). [ Elements ] [ Elements ] [ Elements ] [ Elements ] */ import java.util.*; class stack{ public static void main( String [] args){ Stack < Integer > s= new Stack < Integer >(); //Push Element To Stack s.push( 10 ); s.push( 5 ); s.push( 2 ); s.push( 1 ); System.out.println(s); /* After Push The Stack Like [ 1 ] <---Push And Pop In Top Of The Statck [ 2 ] [ 5 ] [ 10] */ //Pop Element From Statck s.pop(); System.out.println(s); /* After Pop From Stack [ 1 ]--> Pop From Top Of The Stack [ 5 ] [ 10] */ System.out.println(s.peek()); /* s.peek(); Shows Top Of The Stack */ /* s.empty() returns boolean Value

  class node{ int data; node left; node right; node( int data){ this .data=data; } } class treeHeight{ node root; treeHeight(){ root= null ; } public static void main( String [] args){ treeHeight t=new treeHeight(); t.insert( 15 ); t.insert( 20 ); t.insert( 10 ); t.insert( 5 ); t.insert( 2 ); System.out.println(t.height(t.root)); } public void insert( int data){ root=addNode(root,data); } public node addNode(node root, int data){ if (root== null ){ return new node(data); } else if (root.data<data){ root.right=addNode(root.right,data); } else if (root.data>data){ root.left=addNode(root.left,data); } else { return root; } return root; } /* 15,20,10,5 Regression Is Used To Divide a Huge P

  /* Tree is a non-linear Data Structure. root | /------------------------------\ left right | | /--------------\ /-----------------\ left right left right \ \ \ leaf 1.Binary Tree. 2.AVL Tree. 3.Red Black Tree. */ //Structure of Tree In Java Class which hold the Data and pointer of left and right node class node{ int data; node right; node left; node( int data){ this .data=data; } } //Binary Tree Class To Access The node Class class binaryTree{ node root; binaryTree(){ root= null ; } public static void mai

/* Selection Sort is a Basic Sorting Algorithm Based On Comparison of elements. Time Complexity O(n²) Exponential Time. Because We Compare Each N elements In N Single Elements and Swap Them. */ class selectionSort{ public static void main( String [] args){ int [] arr={ 8 , 7 , 6 , 1 , 2 , 4 }; int n=arr.length; for ( int i= 0 ;i<n;i++){ for ( int j=i;j<n;j++){ if (arr[i]>arr[j]){ int temp=arr[i]; arr[i]=arr[j]; arr[j]=temp; } } } for ( int i= 0 ;i<n;i++){ System.out.println(Rand( 10 )); } } }

/* Bubble sort is a Comparison based sorting Algorithm. We Compare T he Array Element With Next or Previous Of Array Element . If The Element Is Higher Or Lower Based on Our Requirement Swap Two.      */ class Bubble{ public static void main( String [] args){ int [] arr={ 7 , 6 , 5 , 4 , 3 , 2 , 1 }; int n=arr.length; int swap= 1 ; int j= 0 ; while (swap> 0 ){ swap= 0 ; for ( int i= 0 ;i<n- 1 ;i++){ if (arr[i]>arr[i+ 1 ]) { int temp=arr[i]; arr[i]=arr[i+ 1 ]; arr[i+ 1 ]=temp; swap++; } } } for ( int i= 0 ;i<n;i++){ System.out.println(arr[i]); } } } output: 1 2 3 4 5 6 7

/* Tail of linked list contains any of it node is known as circle linked list. [10]=>[20]=>[30]----| |====<===<====<===| */ //Instalize the class for list node class node{ int data; node next; node( int data){ this .data=data; } } class circleList{ node head; node tail; public void addNode( int data){ if (head== null ){ head= new node(data); tail=head; } else { tail.next= new node(data); tail=tail.next; tail.next=head; } } public void traverse(node head){ while (head!= null ){ System.out.println(head.data); head=head.next; } } public static void main( String [] args){ circleList cl=new circleList(); cl.addNode( 5 ); cl.addNode( 10 ); cl.addNode( 15 ); } }

class node{ int data; node next; node( int data){ this .data=data; } } class reverseLinkedList{ node head; node tail; node temp;     //Constructor reverseLinkedList(){ head= null ; }          //Reverse Linked List Using Traverse And Add First To New List And Return a List public reverseLinkedList reverse(node head){ reverseLinkedList r2=new reverseLinkedList(); while (head!= null ){ r2.addFirst(head.data); head=head.next; } return r2; }          //Add First Position public void addFirst( int data){ if (head== null ){ head= new node(data); } else { temp= new node(data); temp.next=head; head=temp; } }          //Add Node To Last Element public void addNode( int data){ if (head== null ){ head= new node(data); tail=head; }

//linked list /*     Linked List is a Linear Data Structure.      Drawback of Array Is continues Block Of Memory. Linked Is Used To Allocate the Different Memory Location. Each node Contains Data And Pointer. Header Is Used To Denote The First Node Of Linked List. Tail Is Used To Denote the Last Node of The Linked List. 1.Singly Linked List Each Node as Data And pointer To The Next Node. [ data(header) | pointer of next]->[ data | pointer of next]->[ data | pointer of next]->[ data | null]; 2.doubly Linked List Each Node as Data And pointer To The Next Node and prev Node. [ data(header) | pointer of next]<->[pointer to prev|data | pointer of next]<->[pointer to prev|data | pointer of next]<->[pointer to prev|data | null]; 3.Circle Linked List [ data(header) | pointer of next]->[ data | pointer of next]->[ data | pointer of next]->[ data | null]-->header */ class node{ int data; no

//Array Is a Basic Data Structure in Computer Programming. Array Have Continues Memory Allocation in Memory Space. Data Are Stored In Continues memory space . We Access Using the index Of The Element. Index Start From 0 to n-1 //Basic Operations in Array /* traverse search find insert Remove */ class array{ //Traverse A Array public static void traverse( int [] arr){ int n=arr.length; for ( int i= 0 ;i<n;i++){ System.out.println(arr[i]); } } //Find Value By Index public static void findByIndex( int [] arr, int index){ System.out.println(arr[index]); } //Find Index By Value public static void findIndex( int [] arr, int value){ int n=arr.length; for ( int i= 0 ;i<n;i++){ if (arr[i]==value){ System.out.println(i); } } } //Insert Function (Array Copy Method) public static void insert( int [] arr, int index, int v