From 2aa667e48c4bfdd1f6c67338c4aac1d49b799113 Mon Sep 17 00:00:00 2001 From: TORRYNN Date: Tue, 17 Jun 2025 21:58:18 +0530 Subject: [PATCH] Started LinkedList --- 29_LinkedList/linked$Node.class | Bin 0 -> 359 bytes 29_LinkedList/linked.class | Bin 0 -> 3430 bytes 29_LinkedList/linked.java | 268 ++++++++++++++++++++++++++ 29_LinkedList/tempCodeRunnerFile.java | 1 + file_structure.txt | Bin 6228 -> 12448 bytes 5 files changed, 269 insertions(+) create mode 100644 29_LinkedList/linked$Node.class create mode 100644 29_LinkedList/linked.class create mode 100644 29_LinkedList/linked.java create mode 100644 29_LinkedList/tempCodeRunnerFile.java diff --git a/29_LinkedList/linked$Node.class b/29_LinkedList/linked$Node.class new file mode 100644 index 0000000000000000000000000000000000000000..bfbbec5f2180c8903fc1e909d6f1497a97416d0f GIT binary patch literal 359 zcmYk1y-veG5QJxA6aU1C69)*83W*|dK?+KKnn(ysktsmw&+!R4n6qR%5wArNAyM!E zJQQNjP*Ciwb~QKm?br9mCxB~=U9@0WFg@&{P3W)1R?Kpto@V#STCQqB`zljeeM2xN z)1?C&js@342Ogo5XX;s|XK|5Af|-h15Gc~Fo(CU&UMl&@Dc!|C>m{!z(R9ge-n{e| znUeA5C6VQ$NOI0{ABs)6lDC;2{=PZaa0EM+Ree`fwS^N1>bMnap)_|uAc4&_uzJtQ?4pvAzbl)1|kTrnGI$#apV2B>}VQ}f_ S0~|Jegk$b5N7@+S1kMjPnmlm; literal 0 HcmV?d00001 diff --git a/29_LinkedList/linked.class b/29_LinkedList/linked.class new file mode 100644 index 0000000000000000000000000000000000000000..8da902a02341583d5cb8874a9a891db28adf06ed GIT binary patch literal 3430 zcmb7GZERat8Gep^?Q1*N`D&Zib<(C?+9k2mY-Oa7G+}FK7Bk!JNY}3G*7YX7OWfGk z?)6Q!Y@I+TXov|RA&{n_p)x=fDEw%$xzY-V52=-qC;}utB=`dYjR^r`_nh~6pZ9s+lONuA<2wL`@q7e6_*Ezx0tgB;pVsH~{(^2!_aB-(ZA{q$ z!TotNZ;uH0yL*nR2njS4^5(3O>&ljLMg%G%@^FKI(w*u#8b%b2Dw;GjqlKqkTW(hJ z&l&(I26KN0*GK2cB{BsLpOQ^Hr&BdAW)X) zcu}`|lS2%z$(z$dGE@}_4M`cNlGAOym7MO;(2sirHW&3-W3*&W>GrX_J;PDO)=j%2 zFH7~@eq9KAd5bw$C`e@YX?VYcr8)o#W`vyV)9?XFb4btS#`0Fh4q;Hn=p>`BvyiXY zo%u?qQ7qdFD)tMs)RLJpZDZQ7{2wPmdDn+D+>ZyCo*AQ1HZ0n9-;{$?PfD8k<>$ka zqM#g&X?Rc~P>CR|S8TbK((n;HM8>&B!n#w`fQ%p`BWREohcq06if4l1Km-R z<6=U?5xE<2ch|2ys^J(OrK^0!(5S^Lr!kC+`1{VFiK$yG?7^&J6D`EtRwnlfh*Ao zTc4WE=w)xN6!p9*(AIt8_I&mnWlR&LIctg$%fnvP?2$>~ENfKkj3F{dR=>0jOvBLMBX-7c5}?S=wm0*Ql@EG zqXoTEF&LR58;J^n-*sDzcY?0sIe~5e+mzCFwx7A#4<7Ge(UH8&;g07Qv-A{-2aOK{b+wHDf*1zZW zW28W`xzCMo8SSk*tLVDGX*zKkTe*;U4ZUxm58yh-vGn=1H>KUZRlKhTVK<$FEh2~k zCSV_$Fo+G`8IQk=aBq7R0~aJ4 z?aV~BE)#=_e;}|a5La@qqB*7z(x9>!5a-wa+~>?lPfY3Kw}x(jq5;`fFixB)_RNQf zF3n73n4c`}!XeUj7<=(B^>73a;1OCMbI>-jZQj5ZqUE31NUUss9^x-}^gT#;FQZY? z@SDb77-(fNr{L((?q>=2~Sk>_4$96v@nPLR&Wnbjw# z@{`Q!lN8e_g4LOlDcncl4)er8LY3lD;A@E!9DA?_@v0}R$^RE(+CSXRGXb*P=;VFT zM~?p@hYV>rA;@ro1+k94ed#^)V@@5;5`BT_i=3H6Un2T4(VroDi|B1CbDk1;nsm>T z?gb{{St5T9kK!z2eBPs9X^F2QAj!YRqzUq7;NfKN990DCn z9K|w=eqw&hSA*tO=_hz>k?=lACA@%Ee2T5)(}>|kLi~*5wgLWC1f|nxgx>fAM4I+e1{uQKD8Xfu30cYMz6_;HChK~MTTNf& z*;k10%OvqD4E<{)@jN@s*NJk8n*FAORD*975m%m4oqQxc-zz*X>xsqV(bHHX<=uG4 zIYhZbB+_?BJU5_lIv7|~);1|$LNpfO)?ncL+S{>!Gv@TBsv0CNV3}O5(9df``a0{r z%4U3tD8EI7-$oa{%f|FQ*8lfe|36?SxXhZn;vnCEfX8uT<0`^}F|-gmA962%Z+PU5 zy8(2>DaBd@?!?rl{MLo;vU&MiQqKeT(fL+uXDC>h@6$hOab$t+Q4p%WQ*JQgt#)7Vb zYHjCAmZSBJDn42_^UT&adFvzIDGrajhL6kL1U)~wKA4mP*_YjlvG`5`f90F_HXGjG z*eKqidfsKkf9K2j52oUuY#9IIbM|jOW!Lzw{0Bq0jxnsV3*TU~Si?y^YU=YMgqK7ZuLxF>Xdt_%>C=Z next and head is pointing to the same node + newNode.next = head; + // Step3: Updated the head now head is pointing to he newNode or we can say head + // is having the reference of newNode. + head = newNode; + } + + public void addLast(int data) { + Node newNode = new Node(data); + size++; + if (head == null) { + head = tail = newNode; + } + ; + tail.next = newNode; + tail = newNode; + } + + public void print() { + // Base Condition if LL is empty + if (head == null) { + System.out.print(""); + return; + } + // Created a temporary reference that points to what head is pointing + Node temp = head; + // if our temp becomes null it means we reached end of LL + while (temp != null) { + // Printing data + System.out.print(temp.data + "->"); + // Updating temp to point to next node. + temp = temp.next; + } + System.out.println("null"); + } + + // Add in a middle + public void add(int index, int data) { + if (index == 0) { + addFirst(data); + return; + } + Node newNode = new Node(data); + size++; + Node temp = head; + int i = 0; + while (i < index - 1) { + temp = temp.next; + i++; + + } + newNode.next = temp.next; + temp.next = newNode; + + } + + public int removeFirst() { + if (size == 0) { + System.out.println("Linked- list is empty"); + return Integer.MIN_VALUE; + } else if (size == 1) { + int val = head.data; + head = tail = null; + size = 0; + return val; + } + int val = head.data; + + head = head.next; + size--; + return val; + } + + public int removeLast() { + if (size == 0) { + System.out.println("Linked- list is empty"); + return Integer.MIN_VALUE; + } else if (size == 1) { + int val = head.data; + head = tail = null; + size = 0; + return val; + } + Node prev = head; + + for (int i = 0; i < size - 2; i++) { + prev = prev.next; + } + int val = prev.next.data; + prev.next = null; + tail = prev; + size--; + return val; + } + + public int isearch(int key) { + // A tracker to iterate the linkedlist + Node temp = head; + // Variable to store index + int i = 0; + while (temp != null) { + // If key exist + if (temp.data == key) { + return i; + } + temp = temp.next; + i++; + } + return -1; + } + + // Search in a linkedlist using Recursion + public int helper(Node head, int key) { + if (head == null) { + return -1; + } + if (head.data == key) { + return 0; + } + int idx = helper(head.next, key); + if (idx == -1) { + return -1; + } + return idx + 1; + } + public int rSearch(int key) { + return helper(head, key); + } + += + + // Iterative Approach with Time Complexity is O(n); + public void reverse() { + // Pointer to keep track of the previous node, + Node prev = null; + // Pointer to the current node being processed. + Node curr = tail = head; + // Temporary pointer to store the next node. + Node next; + // Traverse the list until all nodes are reversed(curr becomes null) + while (curr != null) { + // Store the next node before breaking the link + next = curr.next; + // Reverse the link by pointing the current node to previous node. + curr.next = prev; + // Move prev one step forward to current node. + prev = curr; + // Move curr one step forward to the next node. + curr = next; + + } + head = prev; + } + + // Approach 1: Iterative + public void deleteNthFromEnd(int idx) { + // Calculating the size of Linkedlist + Node temp = head; + int size = 0; + while (temp != null) { + temp = temp.next; + size++; + + } + + // Base Condition: If the idx is n means we have to remove first node + if (idx == size) { + head = head.next; + return; + } + + int pos = size - idx; + Node prev = head; + while (--pos > 0) { + prev = prev.next; + + } + prev.next = prev.next.next; + return; + } + + // Approach2: Slow and Fast Pointer + public void deleteNthFromEnd2(int idx) { + // Pointer to calculate the previous positon of node + Node fast = head; + for (int i = 0; i < idx; i++) { + fast = fast.next; + } + if (fast == null) { + head = head.next; + return; + } + // Pointer to get the previous node of the node to be deleted + Node slow = head; + while (fast.next != null) { + fast = fast.next; + slow = slow.next; + + } + slow.next = slow.next.next; + return; + + } + + + + public static void main(String[] args) { + linked ll = new linked(); + ll.print(); + ll.addFirst(2); + ll.print(); + ll.addFirst(1); + ll.print(); + ll.addLast(3); + ll.print(); + ll.addLast(4); + ll.print(); + ll.add(3, 9); + ll.print(); + System.out.println(ll.size); + System.out.println(ll.removeFirst()); + ll.print(); + System.out.println(ll.removeLast()); + ll.print(); + System.out.println(ll.size); + ll.print(); + System.out.println(ll.isearch(3)); + System.out.println(ll.rSearch(3)); + ll.reverse(); + ll.print(); + ll.deleteNthFromEnd(1); + ll.print(); + ll.deleteNthFromEnd2(1); + ll.print(); + } +} diff --git a/29_LinkedList/tempCodeRunnerFile.java b/29_LinkedList/tempCodeRunnerFile.java new file mode 100644 index 0000000..ec747fa --- /dev/null +++ b/29_LinkedList/tempCodeRunnerFile.java @@ -0,0 +1 @@ +null \ No newline at end of file diff --git a/file_structure.txt b/file_structure.txt index c588797b668bd78d23c0d23fab8ee1c03374bc0d..6877af0a39dfc418b46b148a10a29b232533106b 100644 GIT binary patch literal 12448 zcmeHN+ioL85bb9q{=ttRghiZWxxD2Hi*hkZ1melENuAaaDIyO&cYR2ZqEKJAr&7Qe3KjCU>?o45p_?(#ue&1po zM?Bl{EAt47jyc2U8sEQG{{7s17X0pj54qo&A-HzHkJO_QktiLrW4nvB$=UNeF|W;m zIl??H@maldf!}+O;1u6o$U6@1a^zQ#mai^!QUK@4YO%`0$=t!c0p4@G26!(pa&Bi& z?cRX4Ywq#+gc-%Cr_kF9_pZ$wWhC{y#LL-C<6E7>7W6-W)rO^=Mx_>qz#ZexA?_@} z{mQ(xvd8571yXW0#OGYLAni5y4DnwPomq_H9^;?!PC@8pBak8oVLKav6gdbx%J|Sq zTd>7})$SNt_L^o~4dB7c(n^fY8GfZ}{ga)1M({CP_s!jGPauWl387_su;2+S%iQqE zZr%zVQ@4W_U(8aE&>^FQtJ;Oloiki5%rRnyt3$3``Zlh}d4af!TW1ew%v;RUH@FUI z^h~AGOTH9RhuB&cmT4u_5J%7V&G8cV4{gb9MA#{8v&1?|--z3>?r-|6VieN6>f?3a zh*9Jq{5z{y-WsBd@v6gns7dD0$@Ru#~WwajIx0M!arnjKD zLG&-mDoxf!JDp_J6U%=B9M)K_iq>K~P9vkRdUSKinbV2YMT|~DV@9}x)(U8Sf!7e4 z)aDeYkx{t&U`2F^)nJr`)lMlPUOlAAtYsM!?_W(IHDfgi}=jTmIN#avj^`+E2Bg9#mmUvV#Wm*ZfoJ@sebqWcg>eW5l;p2MmDw+xA8uRHr*q=U4{p;&< zeY7OaN$F+uuZd<=+#dgnRF5wYgKmA*+pgFmz}u-tWC^q4{AJV z)DrTg-Q{vcaQlTp*^yumS*|)HN*QruRjy;~!mvNj?yt+@IgPA#pUyN0Y#Azg19mP2$VpXt_ zNV7mYosPDK2ADsqsI11)Fx#mmThX7ThPh8jri! zv`Q$Aha^QG$ZKoYbDYY#H9^yHoJK~W-?$2l9nIVdq;LIBqL z;wt8}&nku4jrrBDTaUQQbIVu+4pomFsUx@#nb{03&0-%CJtgG%14zrx5o=z}l0LI? ztX`2_1D|==kCvn*XVyW?!S39Y(OckzbY_0WeA(Sjkxu6!NkO}DeRR7xYMI`r;kHpp zNSv43z20JGx-OgJCGO|&(LS`NNxm5;aqB||`Yx*(b2@&UMv`R?+iW6D@2fP&OWfHD zV~o@Clcb1Xy~0&o_Y&5fD`X3oH#EzHIf$nRPBuPG;42zeRkW&QfLUA@e&?Q1ot$>3|G3wDP23Qgv!qK`(a9y5@L1NyV>_^ z+H9kekV4PeQ9P>`UB$+*1M@n2VXg~D@Ai8;O=^u=lK$ADFot-B<|BX^c=B!?cKtPd z|Cq;1lFH{X)?uz*DezR0riV7F6eL#p9!bxF9;r^1i=>|x#*j#ri?p4rz3QAum5ZeJ zsbh1}p0Ajf(cpFkVb_7X4R;Q_vi{;KAFe#QCEuT~q!;SYbqXem2E**JiSSZuNK zVH~n@UtkZ$Jd@ss(WoW4e*_+L0Z-@j)AagiiSwCp*(7Bz5{^yf%KfT4H`9Eq%D+k_ zAvNQ!NXYkXRJln1^}OevonVJ=sb+w1tfVQ99K-7DldO{XR!2*m!}#Ut@h0;5vWf=n$T7iB+P!`O_I IxY0KM0A6=RssI20 delta 176 zcmZ3Gc*TI_|Gxx=iA?JzUYNG|9OEKpW?lxa$rm}KH+QjC@K2t@;WXJnRAI7#h#ZhU zG&#*cV6ualz~nGtzR3>yAhyh8JD}JGF}2ASS`e`fVn$FgvB?hNER%V}Vd5aZ09Y