From a637925e8ea7592096f97fe5b940f376ed7ba426 Mon Sep 17 00:00:00 2001 From: Divyansh24051547 <24051547@kiit.ac.in> Date: Thu, 11 Dec 2025 00:28:32 +0530 Subject: [PATCH 1/4] BFS(BREADTH-FIRST-SEARCH) traversal in graph --- Graph$Node.class | Bin 0 -> 378 bytes Graph.class | Bin 0 -> 2251 bytes L | 0 LCS.class | Bin 0 -> 907 bytes LCS.java | 32 ++++++++ Main.class | Bin 0 -> 658 bytes Main.java | 73 +++++++++++++++++ TREE$Node.class | Bin 0 -> 428 bytes TREE.class | Bin 0 -> 2769 bytes customTree.class | Bin 0 -> 771 bytes customTree.java | 176 ++++++++++++++++++++++++++++++++++++++++ knapsackUnbounded.class | Bin 0 -> 860 bytes knapsackUnbounded.java | 36 ++++++++ knapsack_01.class | Bin 0 -> 850 bytes knapsack_01.java | 35 ++++++++ print_LCS.class | Bin 0 -> 1321 bytes print_LCS.java | 47 +++++++++++ 17 files changed, 399 insertions(+) create mode 100644 Graph$Node.class create mode 100644 Graph.class create mode 100644 L create mode 100644 LCS.class create mode 100644 LCS.java create mode 100644 Main.class create mode 100644 Main.java create mode 100644 TREE$Node.class create mode 100644 TREE.class create mode 100644 customTree.class create mode 100644 customTree.java create mode 100644 knapsackUnbounded.class create mode 100644 knapsackUnbounded.java create mode 100644 knapsack_01.class create mode 100644 knapsack_01.java create mode 100644 print_LCS.class create mode 100644 print_LCS.java diff --git a/Graph$Node.class b/Graph$Node.class new file mode 100644 index 0000000000000000000000000000000000000000..282ca71af0ce7587ca2b904f4e5a5f5a7ba74e96 GIT binary patch literal 378 zcmZWlyH3ME5S;TPeqiEYAmLR|P$Who1to}rNPwkailFr8f)C)M z5PNPYD0X)5ZgzI|zJETy0Nmo(hXK=p6~IP|p|j*~e3)~!7(Qi7F{>F`*HX#)hQaI) zrXE~)4*URH2pIhPlE1#3rNvw@SaVSkKN|mOOzKjq#g*=A2ME#8EU8&6Vd(b%QQQFW<*M!&@$VDb3|PJFV#_IpFzC5&JZwh2Rc bB+#Z-6MJ-LU?1Hk_i#wrCrKAQ9Krns@RUPM literal 0 HcmV?d00001 diff --git a/Graph.class b/Graph.class new file mode 100644 index 0000000000000000000000000000000000000000..e02400bb827778abb36635c1349f2704936b19e2 GIT binary patch literal 2251 zcmaJ?-%}G;6#g~|SrQfqL9|h^pgZsI5>zYCvr)5$&%fxxzx&O?Nja{oSYb z59mYXp);Ln$7gK^i_CPK>5LEki~3USce9}clj&r#d-vRPzVn@PzkBar&mR8)U;^KS z;e%gAKtmIP3L-1|x}GZP=2Gg);)=+-3WDQ?X}ISV_y>pPRWvK;s5q5fqnNs+JIk|r zDGU|<5L%$AXw}e$b_Gq-wq9Chm|j>>(3zch2fcs_ zm8@$U=2CiQXgm2sR2FPwiEI8X$i|REaJ#z%LUukH!_CfhS3YZMC;cufLDlKDwEr2 z1C*M|c5&-X5^6|890@`#2|^7tfEua~RB=*4+a5znt_4Y?G`uRStt`rd>u%k?Eo=#ulD>!K<4p~3;evud z$to6!KG=}=2E z7x1Bmk1Aa@X$WyM=^7T1XWI+HA*X1KSpKVN7(&Bsxs=Vj@>dYb8cU|`mTj)*MK7v$ zyN}lc)i_D1jMwhJ^XcB9ezc-%I@RVHp9Ad9(0o&@xP$!gojf5tMjt2kOEj zgnmW%K_z&F&o=n^3^Guqf}0WIVZT}pPZLVc9*OTDvXD6X2+`lsm5?9t>c@*fU1-HY z941Iu-WpY)MZ!zIBM%YYLTnSQ9K^TKy@{wC?Vy*$PHdqs=S>VgK{Bz8Q$FNm1|KBV zC{aM{PF^g>(Ty`Wh9WJ*?rbCRHDtYfN)IDc&ivx#yNAGo9Sk$YnamDG_o)+8Q7{oeP={hcg(fgm zmpd}okgfIHa;5H6Jpt{3+j6}*fnYMVV!}X3hiPE|)){))>$t6T(i=`|-P`EVi#i7B ztgaUQydeu05GA9!Av=$Fvyv>P=1p9Ltz*Q(C0rI5JQc7gd)GAOa{)D3ET)PEMgUO)H)1;R6HVfOOUKO{UdqUA3r8}}Y zYvLNN>$qWI8c9-1^JNz9wi`Q+z;v>o(;H2{*V+G(6dO$=qhrRxO=Jaz&nYCJZ~0{# zt^NpBXy)5B7KxPHmb0|otT>%#veFQC`ndSC&r|K-Y zezL(1vc3RJu(bdm90>B`OG6+>FF`AOB>e^A6CHtD-2E_^VEB`uPpSwJ)rr1OA3}ea z;Wign))LCvcZ37?m0&@&)%ZSkg9Xjj68osz>RTAL_70JlVyk&u3oajEDQ&At?GTZS zt@Z2QMCZTdEh@F_k2QY^)o?;Mn{*Et+zhe9~S+|)n1>+boXgUloA#{W}ieGdi1DUa( zP`Q|r$DRIIP~b%UnMR|rQuNB=XCyK+N0>T9>U5k@C}hOQ8>O5vmK|sIU19;;`vYui BruYB= literal 0 HcmV?d00001 diff --git a/LCS.java b/LCS.java new file mode 100644 index 000000000000..f33c020952fc --- /dev/null +++ b/LCS.java @@ -0,0 +1,32 @@ +import java.util.*; +class LCS{ + + static int solve(String a,String b){ + int n=a.length(),m=b.length(); + int[][] dp=new int[n+1][m+1]; + + for(int i=0;i<=n;i++){ + for(int j=0;j<=m;j++){ + if(i==0 || j==0){ + dp[i][j]=0; + } + else if(a.charAt(i-1)==b.charAt(j-1)){ + dp[i][j]= 1 + dp[i-1][j-1]; + } + else{ + dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]); + } + } + } + + return dp[n][m]; + } + public static void main(String[] args){ + String a="abccdbba"; + String b="jksjccdbaisd"; + + //given two strings , need to find out the longest Common Subsequence + + System.out.println(solve(a,b)); + } +} diff --git a/Main.class b/Main.class new file mode 100644 index 0000000000000000000000000000000000000000..630e824153113f15689d39e917606c4de534fd25 GIT binary patch literal 658 zcmZvaPgB!C7{;G%QnHN!nzdB?gW&%ZX5^;hfas(oz3Ig- z;|WG*ym|5BH}L5ADIDJ=)8T+Q?Edz7-+kZb-N}!?U%mlwF>j&(&46y9h%tupe)KL{ zJc!c4VyC|!?+zKpmXkCYt}tj$t!IEU6q{M}_KgVx8pjnnH@v`aag0-Pd#mlrmWoYU zD8nWxNsr@<3OP=2QN26Nl60_iS!vaJ99J3i^{vq3n4-STj^wz;P;zD1ltE{M^y_r= zw;SGubY+9%Cc{Lp)%E3?FW2Q}DBBz}3`X7e!Z7zUYhey|sGPgnWtjSp88zNL>fDZ! zl(zcOUd%8VBxxL;9QNaEGwL6Zq92~etIp14_q85_**!YRcH`AVC6`pO$7*isewQ9w zeQKrW2E%=#8QPgr=1;*s6EHlWRfU0PDB&R<5v$an(9SP^{0d|H6s2I{l`w^6YroDg zL2L<8-pf&lij7Y>SB0?I_nb{)eQw0lw!W704KZ!w_bA`AwLdxE5>>nKdc>w(tmJH- z;r4~uCm1JtOW;^W1P1IO_29!-3JPh&ZBuYlS=Ks> adj; //creating a adjacency List {source ->destinations} + + public Graph(){ + this.adj=new HashMap<>(); //constructor initializes the adjacency list + } + + static class Node{ //Node class to store the destination place and the distance frome source to destination + String dest; + int dist; + + Node(String dest,int dist){ + this.dest=dest; + this.dist=dist; + } + } + + public static void insert(String src,String dest,int dist){ + insert(src,new Node(dest,dist)); //Undirected weighted graph + insert(dest,new Node(src,dist)); + } + + private static void insert(String src,Node n){ + if(adj.isEmpty() || !adj.containsKey(src)){ + adj.put(src,new ArrayList<>()); + } + adj.get(src).add(n); + } + + public static void BFS(String src){ // BREADTH-FIRST-SEARCH + if(adj.isEmpty()) return; + + HashSet set=new HashSet<>(); + Queue q=new LinkedList<>(); + q.offer(src); + set.add(src); + + while(!q.isEmpty()){ + String node=q.poll(); + System.out.print(node+" "); + List neighbours=adj.get(src); + if(neighbours!=null){ + for(Node neighbour:neighbours){ + if(neighbour!=null && !set.contains(neighbour.dest)){ + q.offer(neighbour.dest); + set.add(neighbour.dest); + } + } + } + } + } + +} + +class Main{ + public static void main(String[] args){ + Graph graph=new Graph(); //instantiating Graph by making an object graph of GRAPH + graph.insert("DELHI","MUMBAI",990); + graph.insert("MUMBAI","PUNE",100); + graph.insert("PUNE","GOA",140); + graph.insert("BANGALORE","PUNE",453); + graph.insert("DELHI","PUNE",1056); + graph.insert("DELHI","HYDERABAD",1099); + graph.insert("VISHAKHAPATNAM","HYDERABAD",230); + graph.insert("BANGALORE","DELHI",1000); + graph.insert("CHENNAI","BANGALORE",600); + graph.insert("CHENNAI","DELHI",1300); + + graph.BFS("DELHI"); + } +} diff --git a/TREE$Node.class b/TREE$Node.class new file mode 100644 index 0000000000000000000000000000000000000000..67229717047f5701cdbb44b29a533aa283f3d795 GIT binary patch literal 428 zcmX|7%TB^T6g>l_rKQsH@PUYr#07LAAE0p|!AL?dQNq5!2qmRW+Twq?ASN#S06)rj zrVAHyPUhaZ=bSq~zhB<~9&lx$fT97-MhUuryYb)se&|Q5{_}hz7ny*57eqmJFHr3E zW+uuo4OliRum#NN%W!x-iI-A9Tl$$VAV%s<)rJF?#ZbOcqcZ+~c&plV8x7SiCBbT) zsmh^^Bc-UXr7Cfowjb3;7tRi?i6JS-hPlQr@Ty z1j-YcW>0aN891kkvKO#NQ6!T==%=YnSyjPtN%sOjL*rp)B2>7Xxn$0aM&@$-rDNg= zZ$nP0xt8|{;kEZLJh8`tf|{r8(fr6qTEtW6M28kGOw>?CofZwsG*M(16l&uv=MFB& K7EQ|NsBnKxw?b|J literal 0 HcmV?d00001 diff --git a/TREE.class b/TREE.class new file mode 100644 index 0000000000000000000000000000000000000000..7f5be410640aca4b0ba2b789002617c9c42c5726 GIT binary patch literal 2769 zcmbtW+jA3D9R4;Ed-NNXrUD3vQ19grAan!HkFFv zcp2fr(a{+laTp)enZEb{$fdxH+^{Dumrg)ucvekCEf)@o>UbY;b)9i;wd zDYH&NC|ahk)8TE=@Pg#6w4?^fyg@@NUZheZUlbOVMxu#wv9f)T#x_bn+le@ukj{kA zp<%NG=+Ef39>i8eRdi~IAx;2`!AR-$G$WAHFVlE5k?2fF<1cC0hHe_SOk1~wf^|zE zFR>lK%Nkyhe)%RQrSJ|7JEd@qkbNhU|;inhoRzFA^`8k3G&hS@!A8F_oewuGMRt!FtL(lCHQ17R28EN);cyywvp{l8u=NKNg74g!w4#BFox4A#x5$P78YX2ssgBdxJSFcyg<^L{yXRJ@~L^9t8i zL#*Om1+D+h%EorxLmMm6#|~j}%E8B-#yuw{zf(NLxhh<1Vh^Ci#+09--gelh`3<3h z-%9w&9)yZ&Io>?M9#60~_5^ChJk;1-)c!B8$0$-q?V?hoPPdZ9A$xuhB zh6OZniEznC1xlHM^|aZFc28=nCsosO2kHXWF99px1JK_fHuA^O>Iq$=6Y?e*e**0> zLgOtD&~__+7n@psKz+Q0JDOg950QCwiUUQw>3J zhVI885`;N~qYlt2_?yE`VIt*x_mJ8QpR9sI5>ZlyBo&WIdtDNnmp2#fVu=1FauS`J zT{mn)tgU0THjFTiV=aeZ9HYc_k~F>~t00I-1Pu;?28kf@KM|ZJf^k|qLj-4u;2aU0 zCxQ#CJ3d+-f>AG9n^^1q+pe>F?%*}%*|Ca(J1&AL2~~-y#!#h>Hq- zMJUzv1Z{+H-=XpH2CC+9=$XJgcJZ>SEY#dL{Dx3muC7wHsGXl1sg17iH89A^KeWV8%!2lIsA)LrR Dr9C-1 literal 0 HcmV?d00001 diff --git a/customTree.class b/customTree.class new file mode 100644 index 0000000000000000000000000000000000000000..f80886af0615b11c8a453d66f7a50f5768d1ff60 GIT binary patch literal 771 zcmZuvTWb?R6#k}3v&m*mqP6u}uhnk4+IXuk6@``vh0vBJCWsHRNr$p!GaF_%1%HZo z7e!GN?1L=|KKbO263^L`R*Um+X3lpm^L;bt*Y9sX0LPU&R;3q;|PvgI3{r%C;s79e-y>4OO(Ps zH6E=cto^XEYyQm{kX4I~!4HYD?1(*CzpR&3QqZG-WC#3?#ny=MjzuQ)(;k5$}bUj}Sj5!Ym z#FOVH*1lewEjOu4J?xu~y6bataj)exOAwF?S}QXjcu}Mx3pa?|?!!`ZeqWM2MIXzH zEqyHnF41Y6cEQNh7Q`1i2wW!1Vc;=xm_~)pocfbWxw!Wo*8MHyYHn+I8@AiZBsQJc zY+_6HU>ihA`NVTun<#AK&?d&d;-uT!@z3t_C-(W1d#vVYe1Ip&;wcJvM$__~CgBB% zdx=TBBCfA7gEzQ?x2WPBmhc|;@Bt6;5elCW;xj3@LOq6X71wCDN!xY$)fr^}04Q{y A2LJ#7 literal 0 HcmV?d00001 diff --git a/customTree.java b/customTree.java new file mode 100644 index 000000000000..4d9e582006e0 --- /dev/null +++ b/customTree.java @@ -0,0 +1,176 @@ +import java.util.*; +class TREE{ + static Node root; + + public TREE(){ // constructor initializes the root + this.root=null; + } + + static class Node{ //Node class + Node left; + Node right; + int data; + int height; + + public Node(int data){ + this.data=data; + this.left=null; + this.right=null; + this.height=1; + } + } + + public static int height(Node n){ + return (n==null)? 0:n.height; + } + + private static int bf(Node n){ // BALANCE FACTOR + return height(n.left)-height(n.right); + } + + public static void insert(int data){ + root=insert(data,root); + } + + private static Node insert(int data,Node root){ + if(root==null){ + return new Node(data); + } + if(root.data <= data){ + root.right=insert(data,root.right); + } + else{ + root.left=insert(data,root.left); + } + + root.height=Math.max(height(root.right),height(root.left))+1; + + return rotate(root); + } + + private static Node rotate(Node root){ + if(bf(root)>1){ //LEFT-HEAVY TREE + if(bf(root.left)>0){ + //LEFT-LEFT + return rightrotate(root); + } + else{ + //LEFT-RIGHT + root.left=leftrotate(root.left); + return rightrotate(root); + } + } + else if(bf(root)<-1){ //RIGHT-HEAVY TREE + if(bf(root.right)<0){ + //RIGHT-RIGHT + return leftrotate(root); + } + else{ + //RIGHT-LEFT + root.right=rightrotate(root.right); + return leftrotate(root); + } + } + return root; + } + + private static Node rightrotate(Node p){ //RIGHT-ROTATION + Node c=p.left; + Node t=c.right; + c.right=p; + p.left=t; + + p.height=Math.max(height(p.right),height(p.left))+1; + c.height=Math.max(height(c.right),height(c.left))+1; + return c; + } + private static Node leftrotate(Node p){ //LEFT-ROTATION + Node c=p.right; + Node t=c.left; + c.left=p; + p.right=t; + + p.height=Math.max(height(p.right),height(p.left))+1; + c.height=Math.max(height(c.right),height(c.left))+1; + return c; + } + + public static void inorder(Node root){ //INORDER TRAVERSAL + if(root==null) return; + + inorder(root.left); + System.out.print(root.data+" "); + inorder(root.right); + } + + public static void preorder(Node root){ //PREORDER TRAVERSAL + if(root==null) return; + + System.out.print(root.data+" "); + preorder(root.left); + preorder(root.right); + } + + public static void postorder(Node root){ //POSTORDER TRAVERSAL + if(root==null) return; + + postorder(root.left); + postorder(root.right); + System.out.print(root.data+" "); + } + + public static void Levelorder(Node root){ //LEVELORDER TRAVERSAL + if(root==null) return; + + Queue q=new LinkedList<>(); + q.offer(root); + q.offer(null); + + while(!q.isEmpty()){ + Node curr=q.poll(); + if(curr==null){ + System.out.println(); + + if(q.isEmpty()) break; + else{ + q.offer(null); + } + } + else{ + System.out.print(curr.data+" "); + + if(curr.left!=null){ + q.offer(curr.left); + } + if(curr.right!=null){ + q.offer(curr.right); + } + } + } + } +} + +class customTree{ + public static void main(String[] args){ + TREE tree=new TREE(); + tree.insert(2); + tree.insert(3); + tree.insert(1); + tree.insert(5); + tree.insert(10); + tree.insert(6); + tree.insert(11); + + tree.inorder(tree.root); + System.out.println(); + + tree.preorder(tree.root); + System.out.println(); + + tree.postorder(tree.root); + System.out.println(); + + tree.Levelorder(tree.root); + } +} + diff --git a/knapsackUnbounded.class b/knapsackUnbounded.class new file mode 100644 index 0000000000000000000000000000000000000000..c50c6d0e1673bc447e4bff574832fcc50c63e88c GIT binary patch literal 860 zcmZuvO-~b16g{u=@!DaaLt!dNE1;+aOo=Seh+%<=NfXMDR7sj@!jw*Mpq(~lN@Qy= zx^kz9ZdtH#qYEX*uyf-dGBE}{Q<@N?nVI+Q$2sqwx$k~I{c-|e894(nC=#j(4Z47} z?e4jAbvM|WbE@0kW+Rr}>k@Gql}f>Yfj$Y-L_Y=u2F`g!H+(`&!+k2C z*4lm$mcq8@HWm$}aY16l#3(Kb z4DJMOYuDY}c^FiiouKB`SZ23b-}40Gxk{lDRWy)6R^pP0aZCsd{pVZ(*@~*v0|7Nx zm|o|0uUX?M$rV5FRy&QV*M8tu>x}f5LKZB#t)8zoT%WXbu5zZh+b_!XgRRBrAfwdm zv^Tx`end|HBRC()!36&+#!CPce(XL3CTV54izqVl8R7#Cfy-Q@G)Ra?ZJ-@Nf6$ZM zU(cK@Wz~(0y73J%c1KkfG+WCaVqaO%Z9Q{{ZCiVbxUIiKa#Xdod0SVUBdpHYnp(@- z`XO%i!n55-&pAui@*9z_*2u~qBSE6w1Dwa516>^besiF4eKD$L=QH{DUAd9;d6--^ z{-=&41&>hnBodhA4BcXGnKRVlj67rfCG)Q^j4NaicZ!sdkm48TF4=c`@Fz6B8zY#tUiLQ1W{H$VOEMb%Zh-s t2uwRgE4B0y$=Ms(W7wZCc76|OmXD-OVGKo%*BWo<5#1-Us7|i5R9{z1P2c&{5Ww4Owh`37cnyR3F18sflFNDV=y2Yw@y2zey1n7zn(f- z%&2Q=b?qx;VqR6|G)K!E;<+-XJ9_#Mbw_)Hq@%xul~NsT*3lLB2*oK!Q)@X#Kg8`0 zJl#fON3D@{MyTc1{vf$ybTQQF@Xv8~Ul&KeUhQjK4^nDoHl2Id795M8g~?T8r#dW3 z9-;6FbYYq|=MK-7cyn638T-Uv@cbnPahVb1ouXezNb!@m&FY@-`vHwFW3S+9XAB2W z`2de>`Nb$Js#{hyx2)-IS(k2ECf#zuhkY)FfW?SUh12J*9O-#83 p+gkhpYx+j!7|usrIR6tvEDsD*z$gkBLy@gKYxd6g|(L58Ii15SW0=m_R5nV+R`yO=%3_!+>NdA)ufjlm!`khA_q+TaJUs zK2p_HSFO}8(n?gywnf53AhBb^nqO0)nlocVlqS;5n>+WOd*40heSG-u%{u@$a4Ufb zqADZ}G8BQ4s{PE))ogzyH(##0m9~I#+4H^jj6l@1788get|Fmf0NO72Lc8VpD}>iv zf2I8-gqKtd(O6n41$iSH4q%js$`iYFos}iCWEB%Q1YO0LhQl}_FtpRaoE?^_+s_4L zvsAKJ`k9JiIgIHJLDQp2}6#m?!yty%Q399(ffPG+e}Y0tZ7LyX#SzP^FsB z3HMRPT8!a)&SaM>6{qSwj^PJ^0l)e0>5&e_fWzf`w9wm4=k?O!Od&{%6#+}mD|JoI(p zvjJrsXO9u?XF%f1jSPVqS}A@-;7PxR_=kqTRgOUzOo#=nXcH<%=vC?cBi(^|CBtFH zkd{-@@_P(MrlshVtjop=tVgF5T}iz_RhNH5Ojmx#a8lCcyskv&w{Rz|%aYTUI86TKc`|1hyN4lEdEkDc|7XU3fsRcguQBT+VqGMmsEF|qLd75z`9yPg zAam?r$b6W>L)KFVe^Xe6iIuk)fA|_Fre$LjbE!>~(ngPOs!unWl>4p@CLU}=x*O5% zR`+94A}*gIMI%pW_AkU4+v>gz!>?ZAbW-kMvV(Iw4AW!-wi)N@9>7sdz(9^o<=NIH zoFKyqJisZGaXMr*0O?b3IgMwJ$V|G<>#es9&INZIOKGE1v!j>hGLzew-q{VK;ij>O RNR#7P%9mwck@yI1eg^+*4nzO| literal 0 HcmV?d00001 diff --git a/print_LCS.java b/print_LCS.java new file mode 100644 index 000000000000..5f39f903e9f6 --- /dev/null +++ b/print_LCS.java @@ -0,0 +1,47 @@ +import java.util.*; +class print_LCS{ + + static void solve(String a,String b){ + int n=a.length(),m=b.length(); + int[][] dp=new int[n+1][m+1]; + + for(int i=0;i<=n;i++){ + for(int j=0;j<=m;j++){ + if(i==0 || j==0){ + dp[i][j]=0; + } + else if(a.charAt(i-1)==b.charAt(j-1)){ + dp[i][j]= 1 + dp[i-1][j-1]; + } + else{ + dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]); + } + } + } + display(a,b,n,m,dp); + } + + static void display(String a,String b,int i,int j,int[][] dp){ + StringBuilder sb=new StringBuilder(); + while(i>0 && j>0){ + if(a.charAt(i-1)==b.charAt(j-1)){ + sb.append(a.charAt(i-1)); + i--; + j--; + } + else{ + if(dp[i-1][j] > dp[i][j-1]) i--; + else j--; + } + } + System.out.println(sb.toString()); + } + + public static void main(String[] args){ + String a="abccdjif"; + String b="njfabccdino"; + // given two strings , need to find Longest Common Subsequence and print it + + solve(a,b); + } +} From c30f6969e6d3f2810c64d50218f0c7464c9cfc15 Mon Sep 17 00:00:00 2001 From: Divyansh24051547 <24051547@kiit.ac.in> Date: Thu, 11 Dec 2025 00:31:28 +0530 Subject: [PATCH 2/4] BFS(BREADTH-FIRST-SEARCH) traversal in graph --- L | 0 LCS.class | Bin 907 -> 0 bytes LCS.java | 32 -------- TREE$Node.class | Bin 428 -> 0 bytes TREE.class | Bin 2769 -> 0 bytes customTree.class | Bin 771 -> 0 bytes customTree.java | 176 ---------------------------------------- knapsackUnbounded.class | Bin 860 -> 0 bytes knapsackUnbounded.java | 36 -------- knapsack_01.class | Bin 850 -> 0 bytes knapsack_01.java | 35 -------- print_LCS.class | Bin 1321 -> 0 bytes print_LCS.java | 47 ----------- 13 files changed, 326 deletions(-) delete mode 100644 L delete mode 100644 LCS.class delete mode 100644 LCS.java delete mode 100644 TREE$Node.class delete mode 100644 TREE.class delete mode 100644 customTree.class delete mode 100644 customTree.java delete mode 100644 knapsackUnbounded.class delete mode 100644 knapsackUnbounded.java delete mode 100644 knapsack_01.class delete mode 100644 knapsack_01.java delete mode 100644 print_LCS.class delete mode 100644 print_LCS.java diff --git a/L b/L deleted file mode 100644 index e69de29bb2d1..000000000000 diff --git a/LCS.class b/LCS.class deleted file mode 100644 index fe07d59091bf47a6e54506ce48862d5483e2525a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 907 zcmZuvO-~b16g{to)+8Q7{oeP={hcg(fgm zmpd}okgfIHa;5H6Jpt{3+j6}*fnYMVV!}X3hiPE|)){))>$t6T(i=`|-P`EVi#i7B ztgaUQydeu05GA9!Av=$Fvyv>P=1p9Ltz*Q(C0rI5JQc7gd)GAOa{)D3ET)PEMgUO)H)1;R6HVfOOUKO{UdqUA3r8}}Y zYvLNN>$qWI8c9-1^JNz9wi`Q+z;v>o(;H2{*V+G(6dO$=qhrRxO=Jaz&nYCJZ~0{# zt^NpBXy)5B7KxPHmb0|otT>%#veFQC`ndSC&r|K-Y zezL(1vc3RJu(bdm90>B`OG6+>FF`AOB>e^A6CHtD-2E_^VEB`uPpSwJ)rr1OA3}ea z;Wign))LCvcZ37?m0&@&)%ZSkg9Xjj68osz>RTAL_70JlVyk&u3oajEDQ&At?GTZS zt@Z2QMCZTdEh@F_k2QY^)o?;Mn{*Et+zhe9~S+|)n1>+boXgUloA#{W}ieGdi1DUa( zP`Q|r$DRIIP~b%UnMR|rQuNB=XCyK+N0>T9>U5k@C}hOQ8>O5vmK|sIU19;;`vYui BruYB= diff --git a/LCS.java b/LCS.java deleted file mode 100644 index f33c020952fc..000000000000 --- a/LCS.java +++ /dev/null @@ -1,32 +0,0 @@ -import java.util.*; -class LCS{ - - static int solve(String a,String b){ - int n=a.length(),m=b.length(); - int[][] dp=new int[n+1][m+1]; - - for(int i=0;i<=n;i++){ - for(int j=0;j<=m;j++){ - if(i==0 || j==0){ - dp[i][j]=0; - } - else if(a.charAt(i-1)==b.charAt(j-1)){ - dp[i][j]= 1 + dp[i-1][j-1]; - } - else{ - dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]); - } - } - } - - return dp[n][m]; - } - public static void main(String[] args){ - String a="abccdbba"; - String b="jksjccdbaisd"; - - //given two strings , need to find out the longest Common Subsequence - - System.out.println(solve(a,b)); - } -} diff --git a/TREE$Node.class b/TREE$Node.class deleted file mode 100644 index 67229717047f5701cdbb44b29a533aa283f3d795..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 428 zcmX|7%TB^T6g>l_rKQsH@PUYr#07LAAE0p|!AL?dQNq5!2qmRW+Twq?ASN#S06)rj zrVAHyPUhaZ=bSq~zhB<~9&lx$fT97-MhUuryYb)se&|Q5{_}hz7ny*57eqmJFHr3E zW+uuo4OliRum#NN%W!x-iI-A9Tl$$VAV%s<)rJF?#ZbOcqcZ+~c&plV8x7SiCBbT) zsmh^^Bc-UXr7Cfowjb3;7tRi?i6JS-hPlQr@Ty z1j-YcW>0aN891kkvKO#NQ6!T==%=YnSyjPtN%sOjL*rp)B2>7Xxn$0aM&@$-rDNg= zZ$nP0xt8|{;kEZLJh8`tf|{r8(fr6qTEtW6M28kGOw>?CofZwsG*M(16l&uv=MFB& K7EQ|NsBnKxw?b|J diff --git a/TREE.class b/TREE.class deleted file mode 100644 index 7f5be410640aca4b0ba2b789002617c9c42c5726..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2769 zcmbtW+jA3D9R4;Ed-NNXrUD3vQ19grAan!HkFFv zcp2fr(a{+laTp)enZEb{$fdxH+^{Dumrg)ucvekCEf)@o>UbY;b)9i;wd zDYH&NC|ahk)8TE=@Pg#6w4?^fyg@@NUZheZUlbOVMxu#wv9f)T#x_bn+le@ukj{kA zp<%NG=+Ef39>i8eRdi~IAx;2`!AR-$G$WAHFVlE5k?2fF<1cC0hHe_SOk1~wf^|zE zFR>lK%Nkyhe)%RQrSJ|7JEd@qkbNhU|;inhoRzFA^`8k3G&hS@!A8F_oewuGMRt!FtL(lCHQ17R28EN);cyywvp{l8u=NKNg74g!w4#BFox4A#x5$P78YX2ssgBdxJSFcyg<^L{yXRJ@~L^9t8i zL#*Om1+D+h%EorxLmMm6#|~j}%E8B-#yuw{zf(NLxhh<1Vh^Ci#+09--gelh`3<3h z-%9w&9)yZ&Io>?M9#60~_5^ChJk;1-)c!B8$0$-q?V?hoPPdZ9A$xuhB zh6OZniEznC1xlHM^|aZFc28=nCsosO2kHXWF99px1JK_fHuA^O>Iq$=6Y?e*e**0> zLgOtD&~__+7n@psKz+Q0JDOg950QCwiUUQw>3J zhVI885`;N~qYlt2_?yE`VIt*x_mJ8QpR9sI5>ZlyBo&WIdtDNnmp2#fVu=1FauS`J zT{mn)tgU0THjFTiV=aeZ9HYc_k~F>~t00I-1Pu;?28kf@KM|ZJf^k|qLj-4u;2aU0 zCxQ#CJ3d+-f>AG9n^^1q+pe>F?%*}%*|Ca(J1&AL2~~-y#!#h>Hq- zMJUzv1Z{+H-=XpH2CC+9=$XJgcJZ>SEY#dL{Dx3muC7wHsGXl1sg17iH89A^KeWV8%!2lIsA)LrR Dr9C-1 diff --git a/customTree.class b/customTree.class deleted file mode 100644 index f80886af0615b11c8a453d66f7a50f5768d1ff60..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 771 zcmZuvTWb?R6#k}3v&m*mqP6u}uhnk4+IXuk6@``vh0vBJCWsHRNr$p!GaF_%1%HZo z7e!GN?1L=|KKbO263^L`R*Um+X3lpm^L;bt*Y9sX0LPU&R;3q;|PvgI3{r%C;s79e-y>4OO(Ps zH6E=cto^XEYyQm{kX4I~!4HYD?1(*CzpR&3QqZG-WC#3?#ny=MjzuQ)(;k5$}bUj}Sj5!Ym z#FOVH*1lewEjOu4J?xu~y6bataj)exOAwF?S}QXjcu}Mx3pa?|?!!`ZeqWM2MIXzH zEqyHnF41Y6cEQNh7Q`1i2wW!1Vc;=xm_~)pocfbWxw!Wo*8MHyYHn+I8@AiZBsQJc zY+_6HU>ihA`NVTun<#AK&?d&d;-uT!@z3t_C-(W1d#vVYe1Ip&;wcJvM$__~CgBB% zdx=TBBCfA7gEzQ?x2WPBmhc|;@Bt6;5elCW;xj3@LOq6X71wCDN!xY$)fr^}04Q{y A2LJ#7 diff --git a/customTree.java b/customTree.java deleted file mode 100644 index 4d9e582006e0..000000000000 --- a/customTree.java +++ /dev/null @@ -1,176 +0,0 @@ -import java.util.*; -class TREE{ - static Node root; - - public TREE(){ // constructor initializes the root - this.root=null; - } - - static class Node{ //Node class - Node left; - Node right; - int data; - int height; - - public Node(int data){ - this.data=data; - this.left=null; - this.right=null; - this.height=1; - } - } - - public static int height(Node n){ - return (n==null)? 0:n.height; - } - - private static int bf(Node n){ // BALANCE FACTOR - return height(n.left)-height(n.right); - } - - public static void insert(int data){ - root=insert(data,root); - } - - private static Node insert(int data,Node root){ - if(root==null){ - return new Node(data); - } - if(root.data <= data){ - root.right=insert(data,root.right); - } - else{ - root.left=insert(data,root.left); - } - - root.height=Math.max(height(root.right),height(root.left))+1; - - return rotate(root); - } - - private static Node rotate(Node root){ - if(bf(root)>1){ //LEFT-HEAVY TREE - if(bf(root.left)>0){ - //LEFT-LEFT - return rightrotate(root); - } - else{ - //LEFT-RIGHT - root.left=leftrotate(root.left); - return rightrotate(root); - } - } - else if(bf(root)<-1){ //RIGHT-HEAVY TREE - if(bf(root.right)<0){ - //RIGHT-RIGHT - return leftrotate(root); - } - else{ - //RIGHT-LEFT - root.right=rightrotate(root.right); - return leftrotate(root); - } - } - return root; - } - - private static Node rightrotate(Node p){ //RIGHT-ROTATION - Node c=p.left; - Node t=c.right; - c.right=p; - p.left=t; - - p.height=Math.max(height(p.right),height(p.left))+1; - c.height=Math.max(height(c.right),height(c.left))+1; - return c; - } - private static Node leftrotate(Node p){ //LEFT-ROTATION - Node c=p.right; - Node t=c.left; - c.left=p; - p.right=t; - - p.height=Math.max(height(p.right),height(p.left))+1; - c.height=Math.max(height(c.right),height(c.left))+1; - return c; - } - - public static void inorder(Node root){ //INORDER TRAVERSAL - if(root==null) return; - - inorder(root.left); - System.out.print(root.data+" "); - inorder(root.right); - } - - public static void preorder(Node root){ //PREORDER TRAVERSAL - if(root==null) return; - - System.out.print(root.data+" "); - preorder(root.left); - preorder(root.right); - } - - public static void postorder(Node root){ //POSTORDER TRAVERSAL - if(root==null) return; - - postorder(root.left); - postorder(root.right); - System.out.print(root.data+" "); - } - - public static void Levelorder(Node root){ //LEVELORDER TRAVERSAL - if(root==null) return; - - Queue q=new LinkedList<>(); - q.offer(root); - q.offer(null); - - while(!q.isEmpty()){ - Node curr=q.poll(); - if(curr==null){ - System.out.println(); - - if(q.isEmpty()) break; - else{ - q.offer(null); - } - } - else{ - System.out.print(curr.data+" "); - - if(curr.left!=null){ - q.offer(curr.left); - } - if(curr.right!=null){ - q.offer(curr.right); - } - } - } - } -} - -class customTree{ - public static void main(String[] args){ - TREE tree=new TREE(); - tree.insert(2); - tree.insert(3); - tree.insert(1); - tree.insert(5); - tree.insert(10); - tree.insert(6); - tree.insert(11); - - tree.inorder(tree.root); - System.out.println(); - - tree.preorder(tree.root); - System.out.println(); - - tree.postorder(tree.root); - System.out.println(); - - tree.Levelorder(tree.root); - } -} - diff --git a/knapsackUnbounded.class b/knapsackUnbounded.class deleted file mode 100644 index c50c6d0e1673bc447e4bff574832fcc50c63e88c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 860 zcmZuvO-~b16g{u=@!DaaLt!dNE1;+aOo=Seh+%<=NfXMDR7sj@!jw*Mpq(~lN@Qy= zx^kz9ZdtH#qYEX*uyf-dGBE}{Q<@N?nVI+Q$2sqwx$k~I{c-|e894(nC=#j(4Z47} z?e4jAbvM|WbE@0kW+Rr}>k@Gql}f>Yfj$Y-L_Y=u2F`g!H+(`&!+k2C z*4lm$mcq8@HWm$}aY16l#3(Kb z4DJMOYuDY}c^FiiouKB`SZ23b-}40Gxk{lDRWy)6R^pP0aZCsd{pVZ(*@~*v0|7Nx zm|o|0uUX?M$rV5FRy&QV*M8tu>x}f5LKZB#t)8zoT%WXbu5zZh+b_!XgRRBrAfwdm zv^Tx`end|HBRC()!36&+#!CPce(XL3CTV54izqVl8R7#Cfy-Q@G)Ra?ZJ-@Nf6$ZM zU(cK@Wz~(0y73J%c1KkfG+WCaVqaO%Z9Q{{ZCiVbxUIiKa#Xdod0SVUBdpHYnp(@- z`XO%i!n55-&pAui@*9z_*2u~qBSE6w1Dwa516>^besiF4eKD$L=QH{DUAd9;d6--^ z{-=&41&>hnBodhA4BcXGnKRVlj67rfCG)Q^j4NaicZ!sdkm48TF4=c`@Fz6B8zY#tUiLQ1W{H$VOEMb%Zh-s t2uwRgE4B0y$=Ms(W7wZCc76|OmXD-OVGKo%*BWo<5#1-Us7|i5R9{z1P2c&{5Ww4Owh`37cnyR3F18sflFNDV=y2Yw@y2zey1n7zn(f- z%&2Q=b?qx;VqR6|G)K!E;<+-XJ9_#Mbw_)Hq@%xul~NsT*3lLB2*oK!Q)@X#Kg8`0 zJl#fON3D@{MyTc1{vf$ybTQQF@Xv8~Ul&KeUhQjK4^nDoHl2Id795M8g~?T8r#dW3 z9-;6FbYYq|=MK-7cyn638T-Uv@cbnPahVb1ouXezNb!@m&FY@-`vHwFW3S+9XAB2W z`2de>`Nb$Js#{hyx2)-IS(k2ECf#zuhkY)FfW?SUh12J*9O-#83 p+gkhpYx+j!7|usrIR6tvEDsD*z$gkBLy@gKYxd6g|(L58Ii15SW0=m_R5nV+R`yO=%3_!+>NdA)ufjlm!`khA_q+TaJUs zK2p_HSFO}8(n?gywnf53AhBb^nqO0)nlocVlqS;5n>+WOd*40heSG-u%{u@$a4Ufb zqADZ}G8BQ4s{PE))ogzyH(##0m9~I#+4H^jj6l@1788get|Fmf0NO72Lc8VpD}>iv zf2I8-gqKtd(O6n41$iSH4q%js$`iYFos}iCWEB%Q1YO0LhQl}_FtpRaoE?^_+s_4L zvsAKJ`k9JiIgIHJLDQp2}6#m?!yty%Q399(ffPG+e}Y0tZ7LyX#SzP^FsB z3HMRPT8!a)&SaM>6{qSwj^PJ^0l)e0>5&e_fWzf`w9wm4=k?O!Od&{%6#+}mD|JoI(p zvjJrsXO9u?XF%f1jSPVqS}A@-;7PxR_=kqTRgOUzOo#=nXcH<%=vC?cBi(^|CBtFH zkd{-@@_P(MrlshVtjop=tVgF5T}iz_RhNH5Ojmx#a8lCcyskv&w{Rz|%aYTUI86TKc`|1hyN4lEdEkDc|7XU3fsRcguQBT+VqGMmsEF|qLd75z`9yPg zAam?r$b6W>L)KFVe^Xe6iIuk)fA|_Fre$LjbE!>~(ngPOs!unWl>4p@CLU}=x*O5% zR`+94A}*gIMI%pW_AkU4+v>gz!>?ZAbW-kMvV(Iw4AW!-wi)N@9>7sdz(9^o<=NIH zoFKyqJisZGaXMr*0O?b3IgMwJ$V|G<>#es9&INZIOKGE1v!j>hGLzew-q{VK;ij>O RNR#7P%9mwck@yI1eg^+*4nzO| diff --git a/print_LCS.java b/print_LCS.java deleted file mode 100644 index 5f39f903e9f6..000000000000 --- a/print_LCS.java +++ /dev/null @@ -1,47 +0,0 @@ -import java.util.*; -class print_LCS{ - - static void solve(String a,String b){ - int n=a.length(),m=b.length(); - int[][] dp=new int[n+1][m+1]; - - for(int i=0;i<=n;i++){ - for(int j=0;j<=m;j++){ - if(i==0 || j==0){ - dp[i][j]=0; - } - else if(a.charAt(i-1)==b.charAt(j-1)){ - dp[i][j]= 1 + dp[i-1][j-1]; - } - else{ - dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]); - } - } - } - display(a,b,n,m,dp); - } - - static void display(String a,String b,int i,int j,int[][] dp){ - StringBuilder sb=new StringBuilder(); - while(i>0 && j>0){ - if(a.charAt(i-1)==b.charAt(j-1)){ - sb.append(a.charAt(i-1)); - i--; - j--; - } - else{ - if(dp[i-1][j] > dp[i][j-1]) i--; - else j--; - } - } - System.out.println(sb.toString()); - } - - public static void main(String[] args){ - String a="abccdjif"; - String b="njfabccdino"; - // given two strings , need to find Longest Common Subsequence and print it - - solve(a,b); - } -} From 0abf46b94bb928b0986a25a140329e5cef35c46d Mon Sep 17 00:00:00 2001 From: Divyansh1802 Date: Thu, 11 Dec 2025 00:57:06 +0530 Subject: [PATCH 3/4] added --- Main.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Main.java b/Main.java index 286b6af98550..a7d2b6e95e77 100644 --- a/Main.java +++ b/Main.java @@ -33,11 +33,11 @@ public static void BFS(String src){ // BREADTH-FIRST-SEARCH if(adj.isEmpty()) return; HashSet set=new HashSet<>(); - Queue q=new LinkedList<>(); + Queue q=new LinkedList<>(); //BFS uses Queue data structure q.offer(src); set.add(src); - while(!q.isEmpty()){ + while(!q.isEmpty()){ String node=q.poll(); System.out.print(node+" "); List neighbours=adj.get(src); From 521e9af6c57e95224cccdca8fb5cb179720539bf Mon Sep 17 00:00:00 2001 From: prashantdubeypng Date: Thu, 11 Dec 2025 22:12:30 +0530 Subject: [PATCH 4/4] feat: Add BreadthFirstSearch algorithm with proper structure and tests - Removed incorrectly placed .class files and Main.java from root - Added BreadthFirstSearch.java with proper package structure - Implemented generic and integer-based BFS traversal methods - Added comprehensive test coverage in BreadthFirstSearchTest.java - Fixed bug in original BFS where 'src' was used instead of 'current' node - Follows project conventions and coding standards Fixes #7158 Co-authored-by: Divyansh1802 --- Graph$Node.class | Bin 378 -> 0 bytes Graph.class | Bin 2251 -> 0 bytes Main.class | Bin 658 -> 0 bytes .../graphs/BreadthFirstSearch.java | 182 ++++++++++++++++++ .../graphs/BreadthFirstSearchTest.java | 171 ++++++++++++++++ 5 files changed, 353 insertions(+) delete mode 100644 Graph$Node.class delete mode 100644 Graph.class delete mode 100644 Main.class create mode 100644 src/main/java/com/thealgorithms/datastructures/graphs/BreadthFirstSearch.java create mode 100644 src/test/java/com/thealgorithms/datastructures/graphs/BreadthFirstSearchTest.java diff --git a/Graph$Node.class b/Graph$Node.class deleted file mode 100644 index 282ca71af0ce7587ca2b904f4e5a5f5a7ba74e96..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 378 zcmZWlyH3ME5S;TPeqiEYAmLR|P$Who1to}rNPwkailFr8f)C)M z5PNPYD0X)5ZgzI|zJETy0Nmo(hXK=p6~IP|p|j*~e3)~!7(Qi7F{>F`*HX#)hQaI) zrXE~)4*URH2pIhPlE1#3rNvw@SaVSkKN|mOOzKjq#g*=A2ME#8EU8&6Vd(b%QQQFW<*M!&@$VDb3|PJFV#_IpFzC5&JZwh2Rc bB+#Z-6MJ-LU?1Hk_i#wrCrKAQ9Krns@RUPM diff --git a/Graph.class b/Graph.class deleted file mode 100644 index e02400bb827778abb36635c1349f2704936b19e2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2251 zcmaJ?-%}G;6#g~|SrQfqL9|h^pgZsI5>zYCvr)5$&%fxxzx&O?Nja{oSYb z59mYXp);Ln$7gK^i_CPK>5LEki~3USce9}clj&r#d-vRPzVn@PzkBar&mR8)U;^KS z;e%gAKtmIP3L-1|x}GZP=2Gg);)=+-3WDQ?X}ISV_y>pPRWvK;s5q5fqnNs+JIk|r zDGU|<5L%$AXw}e$b_Gq-wq9Chm|j>>(3zch2fcs_ zm8@$U=2CiQXgm2sR2FPwiEI8X$i|REaJ#z%LUukH!_CfhS3YZMC;cufLDlKDwEr2 z1C*M|c5&-X5^6|890@`#2|^7tfEua~RB=*4+a5znt_4Y?G`uRStt`rd>u%k?Eo=#ulD>!K<4p~3;evud z$to6!KG=}=2E z7x1Bmk1Aa@X$WyM=^7T1XWI+HA*X1KSpKVN7(&Bsxs=Vj@>dYb8cU|`mTj)*MK7v$ zyN}lc)i_D1jMwhJ^XcB9ezc-%I@RVHp9Ad9(0o&@xP$!gojf5tMjt2kOEj zgnmW%K_z&F&o=n^3^Guqf}0WIVZT}pPZLVc9*OTDvXD6X2+`lsm5?9t>c@*fU1-HY z941Iu-WpY)MZ!zIBM%YYLTnSQ9K^TKy@{wC?Vy*$PHdqs=S>VgK{Bz8Q$FNm1|KBV zC{aM{PF^g>(Ty`Wh9WJ*?rbCRHDtYfN)IDc&ivx#yNAGo9Sk$YnamDG_(oz3Ig- z;|WG*ym|5BH}L5ADIDJ=)8T+Q?Edz7-+kZb-N}!?U%mlwF>j&(&46y9h%tupe)KL{ zJc!c4VyC|!?+zKpmXkCYt}tj$t!IEU6q{M}_KgVx8pjnnH@v`aag0-Pd#mlrmWoYU zD8nWxNsr@<3OP=2QN26Nl60_iS!vaJ99J3i^{vq3n4-STj^wz;P;zD1ltE{M^y_r= zw;SGubY+9%Cc{Lp)%E3?FW2Q}DBBz}3`X7e!Z7zUYhey|sGPgnWtjSp88zNL>fDZ! zl(zcOUd%8VBxxL;9QNaEGwL6Zq92~etIp14_q85_**!YRcH`AVC6`pO$7*isewQ9w zeQKrW2E%=#8QPgr=1;*s6EHlWRfU0PDB&R<5v$an(9SP^{0d|H6s2I{l`w^6YroDg zL2L<8-pf&lij7Y>SB0?I_nb{)eQw0lw!W704KZ!w_bA`AwLdxE5>>nKdc>w(tmJH- z;r4~uCm1JtOW;^W1P1IO_29!-3JPh&ZBuYlS=Ks + * BFS is a graph traversal algorithm that explores all vertices at the present + * depth level before moving on to vertices at the next depth level. It uses a + * queue + * data structure to keep track of vertices to visit. + * + *

+ * Time Complexity: O(V + E) where V is the number of vertices and E is the + * number of edges. + * Space Complexity: O(V) for the visited set and queue. + * + *

+ * References: + *

    + *
  • https://en.wikipedia.org/wiki/Breadth-first_search
    • + *
+ * + * @author Divyansh1802 + * @author prashantdubeypng (fixes and refactoring) + */ +public final class BreadthFirstSearch { + + private BreadthFirstSearch() { + // Utility class; do not instantiate. + } + + /** + * Performs BFS traversal on a graph represented as an adjacency list. + * + * @param adjacencyList the graph represented as a map from vertex to list of + * neighbors + * @param source the starting vertex for traversal + * @param the type of vertices in the graph + * @return a list of vertices in BFS order starting from the source + * @throws IllegalArgumentException if source is null or not in the graph + */ + public static List bfs(Map> adjacencyList, T source) { + if (source == null) { + throw new IllegalArgumentException("Source vertex cannot be null"); + } + if (adjacencyList == null || !adjacencyList.containsKey(source)) { + throw new IllegalArgumentException("Source vertex must exist in the graph"); + } + + List result = new ArrayList<>(); + Set visited = new HashSet<>(); + Queue queue = new LinkedList<>(); + + queue.offer(source); + visited.add(source); + + while (!queue.isEmpty()) { + T current = queue.poll(); + result.add(current); + + List neighbors = adjacencyList.get(current); + if (neighbors != null) { + for (T neighbor : neighbors) { + if (!visited.contains(neighbor)) { + visited.add(neighbor); + queue.offer(neighbor); + } + } + } + } + + return result; + } + + /** + * Performs BFS traversal on a graph represented using integer vertices. + * + * @param adjacencyList the graph represented as a list of lists of neighbors + * @param numVertices the number of vertices in the graph + * @param source the starting vertex for traversal (0-indexed) + * @return a list of vertices in BFS order starting from the source + * @throws IllegalArgumentException if source is out of bounds + */ + public static List bfs(List> adjacencyList, int numVertices, int source) { + if (source < 0 || source >= numVertices) { + throw new IllegalArgumentException("Source vertex is out of bounds"); + } + if (adjacencyList == null) { + throw new IllegalArgumentException("Adjacency list cannot be null"); + } + + List result = new ArrayList<>(); + boolean[] visited = new boolean[numVertices]; + Queue queue = new LinkedList<>(); + + queue.offer(source); + visited[source] = true; + + while (!queue.isEmpty()) { + int current = queue.poll(); + result.add(current); + + if (current < adjacencyList.size()) { + List neighbors = adjacencyList.get(current); + if (neighbors != null) { + for (int neighbor : neighbors) { + if (neighbor >= 0 && neighbor < numVertices && !visited[neighbor]) { + visited[neighbor] = true; + queue.offer(neighbor); + } + } + } + } + } + + return result; + } + + /** + * Creates an adjacency list graph from edges. + * + * @param numVertices the number of vertices + * @param edges array of edges where each edge is {from, to} + * @param undirected if true, adds edges in both directions + * @return the adjacency list representation of the graph + */ + public static List> createGraph(int numVertices, int[][] edges, boolean undirected) { + List> graph = new ArrayList<>(); + for (int i = 0; i < numVertices; i++) { + graph.add(new ArrayList<>()); + } + + for (int[] edge : edges) { + if (edge.length >= 2) { + int from = edge[0]; + int to = edge[1]; + if (from >= 0 && from < numVertices && to >= 0 && to < numVertices) { + graph.get(from).add(to); + if (undirected) { + graph.get(to).add(from); + } + } + } + } + + return graph; + } + + /** + * Creates a Map-based adjacency list from string vertices. + * + * @param edges array of edges where each edge is {from, to} + * @param undirected if true, adds edges in both directions + * @return the adjacency list representation as a Map + */ + public static Map> createStringGraph(String[][] edges, boolean undirected) { + Map> graph = new HashMap<>(); + + for (String[] edge : edges) { + if (edge.length >= 2) { + String from = edge[0]; + String to = edge[1]; + + graph.computeIfAbsent(from, k -> new ArrayList<>()).add(to); + if (undirected) { + graph.computeIfAbsent(to, k -> new ArrayList<>()).add(from); + } + } + } + + return graph; + } +} diff --git a/src/test/java/com/thealgorithms/datastructures/graphs/BreadthFirstSearchTest.java b/src/test/java/com/thealgorithms/datastructures/graphs/BreadthFirstSearchTest.java new file mode 100644 index 000000000000..ffbc523d0466 --- /dev/null +++ b/src/test/java/com/thealgorithms/datastructures/graphs/BreadthFirstSearchTest.java @@ -0,0 +1,171 @@ +package com.thealgorithms.datastructures.graphs; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.junit.jupiter.api.Test; + +/** + * Tests for {@link BreadthFirstSearch}. + */ +class BreadthFirstSearchTest { + + @Test + void testBfsWithIntegerGraphSimple() { + // Create a simple graph: 0 -> 1 -> 2 + // | | + // v v + // 3 4 + int[][] edges = { { 0, 1 }, { 0, 3 }, { 1, 2 }, { 1, 4 } }; + List> graph = BreadthFirstSearch.createGraph(5, edges, false); + + List result = BreadthFirstSearch.bfs(graph, 5, 0); + + assertEquals(5, result.size()); + assertEquals(0, result.get(0)); // Source is first + // BFS visits by level: 0 -> [1, 3] -> [2, 4] + assertTrue(result.indexOf(1) < result.indexOf(2)); // 1 before 2 + assertTrue(result.indexOf(1) < result.indexOf(4)); // 1 before 4 + } + + @Test + void testBfsWithUndirectedGraph() { + // Create an undirected graph + int[][] edges = { { 0, 1 }, { 1, 2 }, { 2, 3 }, { 3, 4 } }; + List> graph = BreadthFirstSearch.createGraph(5, edges, true); + + List result = BreadthFirstSearch.bfs(graph, 5, 2); + + assertEquals(5, result.size()); + assertEquals(2, result.get(0)); // Source is first + } + + @Test + void testBfsWithDisconnectedGraph() { + // Graph with disconnected components: 0 -> 1, 2 -> 3 (separate components) + int[][] edges = { { 0, 1 }, { 2, 3 } }; + List> graph = BreadthFirstSearch.createGraph(4, edges, false); + + List result = BreadthFirstSearch.bfs(graph, 4, 0); + + // Should only visit reachable vertices from 0 + assertEquals(2, result.size()); + assertTrue(result.contains(0)); + assertTrue(result.contains(1)); + } + + @Test + void testBfsWithSingleVertex() { + int[][] edges = {}; + List> graph = BreadthFirstSearch.createGraph(1, edges, false); + + List result = BreadthFirstSearch.bfs(graph, 1, 0); + + assertEquals(1, result.size()); + assertEquals(0, result.get(0)); + } + + @Test + void testBfsWithCyclicGraph() { + // Graph with a cycle: 0 -> 1 -> 2 -> 0 + int[][] edges = { { 0, 1 }, { 1, 2 }, { 2, 0 } }; + List> graph = BreadthFirstSearch.createGraph(3, edges, false); + + List result = BreadthFirstSearch.bfs(graph, 3, 0); + + assertEquals(3, result.size()); + assertEquals(0, result.get(0)); // Source is first + } + + @Test + void testBfsWithMapBasedGraph() { + Map> graph = new HashMap<>(); + graph.put("A", List.of("B", "C")); + graph.put("B", List.of("D")); + graph.put("C", List.of("E")); + graph.put("D", new ArrayList<>()); + graph.put("E", new ArrayList<>()); + + List result = BreadthFirstSearch.bfs(graph, "A"); + + assertEquals(5, result.size()); + assertEquals("A", result.get(0)); // Source is first + // B and C should come before D and E + assertTrue(result.indexOf("B") < result.indexOf("D")); + assertTrue(result.indexOf("C") < result.indexOf("E")); + } + + @Test + void testBfsWithStringGraphCreation() { + String[][] edges = { { "DELHI", "MUMBAI" }, { "DELHI", "PUNE" }, { "MUMBAI", "GOA" } }; + Map> graph = BreadthFirstSearch.createStringGraph(edges, true); + + List result = BreadthFirstSearch.bfs(graph, "DELHI"); + + assertEquals(4, result.size()); + assertEquals("DELHI", result.get(0)); + } + + @Test + void testBfsThrowsExceptionForNullSource() { + Map> graph = new HashMap<>(); + graph.put("A", List.of("B")); + + assertThrows(IllegalArgumentException.class, () -> BreadthFirstSearch.bfs(graph, null)); + } + + @Test + void testBfsThrowsExceptionForSourceNotInGraph() { + Map> graph = new HashMap<>(); + graph.put("A", List.of("B")); + + assertThrows(IllegalArgumentException.class, () -> BreadthFirstSearch.bfs(graph, "X")); + } + + @Test + void testBfsThrowsExceptionForInvalidSourceIndex() { + List> graph = BreadthFirstSearch.createGraph(3, new int[][] {}, false); + + assertThrows(IllegalArgumentException.class, () -> BreadthFirstSearch.bfs(graph, 3, -1)); + assertThrows(IllegalArgumentException.class, () -> BreadthFirstSearch.bfs(graph, 3, 5)); + } + + @Test + void testBfsLevelOrderProperty() { + // Test that BFS visits vertices level by level + // 0 + // /|\ + // 1 2 3 + // | | + // 4 5 + int[][] edges = { { 0, 1 }, { 0, 2 }, { 0, 3 }, { 1, 4 }, { 3, 5 } }; + List> graph = BreadthFirstSearch.createGraph(6, edges, false); + + List result = BreadthFirstSearch.bfs(graph, 6, 0); + + // Level 0: 0 + // Level 1: 1, 2, 3 + // Level 2: 4, 5 + assertEquals(0, result.get(0)); + // All level-1 vertices come before level-2 vertices + int level1End = Math.max(result.indexOf(1), Math.max(result.indexOf(2), result.indexOf(3))); + int level2Start = Math.min(result.indexOf(4), result.indexOf(5)); + assertTrue(level1End < level2Start); + } + + @Test + void testBfsWithEmptyNeighborList() { + Map> graph = new HashMap<>(); + graph.put("A", new ArrayList<>()); + + List result = BreadthFirstSearch.bfs(graph, "A"); + + assertEquals(1, result.size()); + assertEquals("A", result.get(0)); + } +}