Lecture 46: Linked List Questions: Reverse LL in "K group" && Check LL is Circular or not

[@CodeHelp]

Do Visit Relevel: relvl.co/444e

[@comment6130]

First like

[@ancymaria3907]

Hi love..pls add subtitles for ur video.. Last three DSA course videos doesn't have subtitles.. It wud b really helpful for people like me who doesn't know hindi

[@mohitraj1995]

I m in lecture 5🙂 I want complete fast to cover and see daily wise latest update

[@ashutosh61290]

@Devesh bhai wo bhi insaan hai.. thoda unke bare me bhi socho. itna speed toh video daal rhe hai.. ab kya ek din me 5 video daal de tumhare liye.

[@nehasharma6171]

circularlly linked ka ques code studio pe is logic se karne se saare test cases ren nhi horhe h . 😔

[@anishtripathi3800]

Watching this in July 2024.. still the best lecture series, and I will complete it all. To the people watching it, I request you to not watch it from the middle if you're a beginner. I had consistently watched it from lecture 1, and trust me, this will help you pass with flying colors.

[@feagy]

FOR EVERY ONE DOING IT NOW TEST CASE HAS BEEN CHANGED ...current code will work after doing little bit change HERE IS THE CORRECT CODE int getlength(Node*head,int k){ int c=0; while(head!=NULL){ c++; head=head->next; } return c; } Node* kReverse(Node* head, int k) { // Write your code here. //base case if(head==NULL){ return NULL; } Node*prev=NULL; Node*curent=head; Node*forward=NULL; int c=0; while(curent!=NULL && cnext; curent->next=prev; prev=curent; curent=forward; c++; } // if(forward!=NULL ){ // head->next=kreverse(forwars,k); if(getlength(forward,k)>=k){ head->next = kReverse(forward, k); } else{ head->next=forward; } } return prev; }

[@mannan7126]

thanks man :))

[@manavgupta1558]

Only adding getlength on base condition can give correct answer i.e. int getlength(ListNode* head){ int n=0; ListNode* temp = head; while (temp!=NULL) { temp=temp->next; n++; } return n; } ListNode* reverseKGroup(ListNode* head, int k) { if(head==NULL || getlength(head)next=prev; prev=curr; curr=temp; cnt++; } if(temp!=NULL) head-> next= reverseKGroup(curr,k); return prev; } hope so its easier to understand.

[@aviii24x7]

After 2 hours of trying, you helped htanks!!!

[@khushigupta1783]

what change has been made to the question now?can anyone tell..is it that the nodes out of the k value left at end will be left as it is?

[@aviii24x7]

@@khushigupta1783 The node that left (less than k) should not be affected, changes to be applied only if next k nodes are availbale

[@viral_plays1081]

Dheerr sarreee bde se bdee youtube channels, but apki energy and way of teaching.....MIND BLOWING!!!!

[@ninjahattori4101]

NIce Explanation Keep the josh high, we are with you following the course from the very start video

[@sauravdhar1696]

Completing the first phase in depth but still watching the videos that you upload daily taaki aapka motivation na down ho bhaiyya ....awesome work (march tak khatam kar denge sab kuch)

[@snipper6683]

konse year may ho bhai!

[@AS-gf3ci]

For Leetcode : (Only slight changes to this video's solution) int getLength(ListNode* head) { int length = 0; ListNode* temp =head; while(temp != NULL) { length++; temp = temp -> next; } return length; } ListNode* reverseK(ListNode* &head, int k, int length) { //Base case if(head == NULL || head -> next == NULL || k == 1 || length < k) return head; //Step 1 : Reverse first k nodes ListNode* nxt = NULL; ListNode* curr = head; ListNode* prev = NULL; int count = 1; while(curr != NULL && count next; curr -> next = prev; prev = curr; curr = nxt; count++; } //Step 2 : Reverse next k nodes using recursion if(nxt != NULL) { head -> next = reverseK(nxt, k, (length - k)); } //Step 3 : Return head of the reversed linked list head = prev; return head; } ListNode* reverseKGroup(ListNode* head, int k) { int len = getLength(head); return reverseK(head, k, len); }

[@shantanumore5396]

thanks much needed!

[@dreamy4174]

Getting difficulty in recusion problems .Any suggestion 🥺

[@vakeelsaab5485]

@@dreamy4174 spend more time on recursion dry run

[@meetmakwana3427]

Thanks a ton MVP

[@motives748]

bro the length function is much needed without it the solution gives wrong ans thanks

[@RedSpade01]

APPROACH For anyone stucking in cases in codestudio or leetcode, the problem is this code reverses even if k is greater than remaining numbers, so you gotta check the size in every recursion(basically in one case your working), then mark k>size{return head}, this will do the job. edit: I will post my edited code but try once yourselves its easy

[@tejasshinde7236]

Thanks

[@rohitss671]

yes i also found that after reading the question i understand what to do ---

[@Sukoon_3000]

thanks but was stuck for 1 hr

[@PrajjvalMishra-g5f]

thanks

[@RedSpade01]

@@Sukoon_3000 No prob buddy, I was stuck for an hour here too😅

[@deeppatel0586]

Babbar sir, love your content. told many friends about this course. Infinite gratitude from my side :)))))))))

[@RahulKumar-ye2iy]

This code will reverse every elements in group even if the no. of elements in one group is less than k. So, here's the updated code which will take care this condition. class Solution { public: ListNode* _reverseKGroup(ListNode* head, int size, int k){ if(head==nullptr || sizenext=prev; prev=cur; cur=next; count++; } head->next=_reverseKGroup(next, size-k, k); return prev; } ListNode* reverseKGroup(ListNode* head, int k) { int size=0; ListNode* temp=head, *root; while(temp!=nullptr){ temp=temp->next; size++; } return _reverseKGroup(head, size, k); } };

[@shubhamgarad657]

Thanks guru

[@codehunter-gu1qi]

not working input : 6 5 4 3 7 9 2 4 output : 7 3 4 5 desired output : 7 3 4 5 9 2

[@anushravgarg5042]

Bhaiya excellent work, after 5 months i am seeing these videos but this is one of the really nice explained content i have got ,even after seeing 1-2 paid courses i can say this clearly that this is best and keep up good work babbar bhai

[@daiict2282]

Easiest solution of k reverse hats off bhaiya kya smjhaya ha apki wahaj sa kitna bacho ka future secure ho raha ha

[@kaushikjain9697]

Babbar sir, love your content. told many friends about this course. Infinite gratitude from my side

[@sakshamgarg5638]

Keep the josh high, we are with you following the course from the very start video

[@harshjain7945]

Your way of teaching is unmatchable sir! Big fan of you sir!

[@rahulstudies1178]

doubly linked list reverse Node* reverseDLL(Node * head) { Node* curr=head; Node* pre=NULL; Node* forward=NULL; while(curr!=NULL){ forward=curr->next; curr->prev=curr->next; curr->next=pre; pre=curr; curr=forward; } return pre; }

[@sushil4-yearb.tech.electri218]

If anyone doing now is getting stucked in some test cases, then the updated code is here : Node* kReverse(Node* head, int k) { int size = 0; Node* temp = head; while(temp!=NULL){ temp = temp -> next; size++; } if(size < k)return head; // just add this new part in code so that, when number of nodes is not a multiple of k, the left over ones are not to be reversed. if(head == NULL){ return NULL; } // step 1: reverse first k nodes Node* prev = NULL; Node* curr = head; Node* next = NULL; int count = 0; while(curr != NULL && count < k){ next = curr -> next; curr -> next = prev; prev = curr; curr = next; count ++; } // step 2: recursion if(next != NULL){ head -> next = kReverse(next, k); } // step 3: return head return prev; }

[@Anshucc]

nice edge case pass ho gye badhiya code logic

[@aditighate7191]

@@Anshucc Thank you!

[@ankitgaur7428]

Thanks bro

[@simplesolutions2621]

Excellent going, bhaiya!! Keep the Josh High!!! Hum SAATH HAI!!❤ Thode din ka gap ho sakta hai..to cover up and do more questions from previous videos!! 👍

[@samaysarah7417]

Dhanyawaad bhaiya iss course ke liye....

[@investwithus9271]

Daily video chahiye... We support you... Completed video

[@siddharthsingh5510]

In question 1: reverse linked list in k groups, this is O(1) space complexity and O(n) time complexity code which i written myself: Passed all the testcases. Node* kReverse(Node* head, int k) { Node* curr = head; Node* prev = NULL; Node* forward = NULL; int j=0; Node* ultimatehead = NULL; Node* mogambo = NULL; while(curr!=NULL){ Node* tempo = curr; int i=1; while(inext; prev = curr; curr = forward; i++; } else{ forward = curr->next; curr->next = prev; prev = curr; curr = forward; i++; } } if(j==0){ ultimatehead = prev; tempo->next = curr; prev = tempo; mogambo = tempo; j++; } else{ mogambo->next = prev; tempo->next = curr; prev = tempo; mogambo = tempo; j++; } } return ultimatehead; }

[@arncs5587]

Class ase chalraha he ki may be meri break failure ho jayega 😂😂😂👍👍👍 thanks bhai continue ......❤️❤️ Lot of love from Amosh ....❤️❤️❤️

[@srivathsav4587]

For leetcode you have to stop if there are less than k nodes: Just add this after your, if(head==NULL) condition: ListNode *d=head; for(int i=0;inext; }

[@maidaiftikhar6901]

could you please explain the logic for this?

[@AkshatChaudhary-fe3vv]

Bro check LL is giving TLE in coding studio 😢

[@naitik554]

Bhaiya hum dekhte hain aap banate jaaye.... Josh is always high because of you and your consistency.... Thank you bhaiyaa....😊😊

[@Nishankjain-cw4jh]

question 1 contains one more base condition that if the length is less than k than return rest of the LL as it is here is the enhanced code /** * Definition for singly-linked list. * class Node { * public: * int data; * Node *next; * Node() : data(0), next(nullptr) {} * Node(int x) : data(x), next(nullptr) {} * Node(int x, Node *next) : data(x), next(next) {} * }; */ Node *kReverse(Node *head, int k) { if (head == NULL) return head; int len = 0; Node *check = head; while (check != NULL) { len++; check = check->next; } if (len < k) { return head; } if (head == NULL) { return NULL; } // step1: reverse first k nodes Node *prev = NULL; Node *curr = head; Node *next = NULL; int count = 0; while (curr != NULL && count < k) { next = curr->next; curr->next = prev; prev = curr; curr = next; count++; } // step2: Recursion dekhlega aage ka if (next != NULL) { head->next = kReverse(next, k); } // step3: return head of reversed list return prev; }

[@GaneshBhutekar-nu1gd]

bro tu knse year main hain

[@AbhishekVerma-gg4hf]

Bhaiya aap ka hi Sahara hain ..aap kyu apna motivation down kr rahe ho . We are with you🤝

[@sambhavsharma2780]

For leetcode class Solution { public: ListNode* reverseKGroup(ListNode* head, int k) { if(head == NULL) return NULL; // reverse first k nodes ListNode* prev = NULL; ListNode* curr = head; ListNode* forward = NULL; ListNode* temp = head; int count = 0; // count remaining nodes int countNodes = 0; while(temp != NULL){ countNodes++; temp = temp->next; } if(countNodes >= k){ while(curr != NULL && count < k){ forward = curr->next; curr->next = prev; prev = curr; curr = forward; count++; } if(forward != NULL){ head->next = reverseKGroup(forward, k); } }else{ return head; } return prev; } };

[@neerajmahapatra5239]

Can you explain why countNodes>=k working

[@sambhavsharma2780]

@@neerajmahapatra5239 it works because every time when we call next reverseKGroup function. first we count remaining nodes and if remaining nodes is greater than or equal to K then we only reverse that group if it is less than K then we simply return head means no need to reverse further. Hope you understand.

[@111rhishishranjan2]

Post leetcode code for circular linkedlist or not

[@parthibbanerjee5994]

​@@sambhavsharma2780 for i/p : 1 2 3 4 5 and k = 3......after the reversal of (1, 2, 3) when it comes to the recursion part for (4, 5), countnodes=2..... so (countnodes >= k) condition becomes false right??....then in that case how reversal of (4, 5) is happening?? can u pls explain this!!

[@rakshitgupta1771]

@@parthibbanerjee5994 do this little change in it.... node *reversek(node *head, int k) { if (head == NULL) { return NULL; } node *temp = head; int cntnodes = 0; node * ans = NULL; while (temp != NULL) { cntnodes++; temp = temp->next; } if (cntnodes >= k) { node *forw = NULL; node *curr = head; node *prev = NULL; int cnt = 0; while (curr != NULL && cnt < k) { forw = curr->next; curr->next = prev; prev = curr; curr = forw; cnt++; } if (forw != NULL) { head->next = reversek(forw, k); } ans = prev; } else return head; return ans; }

[@sounaksaha1455]

Ennnnnnnnnerrrrrrrrggggy!!!!! Bhaiya aap video laate rahiye....... hum placement leke hi manenge.

[@amandwivedi976]

Bhaiya abhi mai lecture 20 pe hoon, Attendence marked thnq so much for awesome videos

[@AbhishekVerma-gg4hf]

Bhaiya aap lage raho hm log aap k saath hain

[@SriniVas-mx1li]

Bhai tuuu... humra pyaar hi ♥️ Attendance from Andhra Pradesh 🥳🥳🥳

[@anuragpandey8165]

39:54 Bhai dekh rahe hai hamesha.... Like bhi krre hai...... Roz video chahiye

[@prishasureja5280]

woaahhh sir pls keep uploading we are watching this series regularly!!!!!

[@ekengineer9868]

Bhaiyaa ji consistency op🔥 And don't get disappointed by less comments it is because many of us are left with previous lectures 🥲

[@sabhavathyashwanth9145]

Hello sir I'm a btech 1st year student of it branch. I'm done with C and wanted to switch to C++. Kya mein es playlist ko follow kar sakta hun ya should I see other playlist like whole C++ lectures as esme DSA bhi included hai na. Please suggest me

[@_MadhviSharma]

@@sabhavathyashwanth9145 you can follow this series, it would be really helpful for you. And in 3rd sem there is dsa subject, so you can prepare it smoothly.

[@sabhavathyashwanth9145]

@@_MadhviSharma thanks mam for your reply Mam which lang. is better for DSA C or C++. As per my clg syllabus we have DSA subject right in 2nd sem and OOPS in 3rd sem and prof. teaches us in C it seems

[@cyberserker]

@@sabhavathyashwanth9145 Start with C and switch to C++ after you've done the Basic Data structures in C , that way your college syllabus will get covered. BTW C and C++ are not very different so you wont face any problems! :D

[@_MadhviSharma]

I had just completed the first phase of this series..thank you so much sir for such content. Please provide handwritten notes from 6th lecture onwards.

[@sounaksaha1455]

6th aur 7th ka aa gaya hai ji....... dekh lijiye

[@_MadhviSharma]

@@sounaksaha1455 thank you!

[@sidtech10]

@@sounaksaha1455 handwritten notes kaha hai🤔

[@udaypratapsingh8923]

bhaiyaa aapka course dhoom machane vaala hai ...

[@akashdeepmaity639]

Taking 100 days DSA challenge from here on and going to comment in next videos everyday after completion........ Day -1 :: Completed

[@ravivishvas3676]

Incomparable efforts 🔥

[@sounaksaha1455]

Love you bhaiya... Hope everyone will get their dream placement

[@manishabose8012]

To those watching this video after this comment has been posted: the question 'Reverse List in K Groups' has been changed by CodingNinja (not sure why they did it). The solution in the video won't work completely; you need to reverse it again if the last group has fewer than k nodes to restore the original order. So, you’ll need to add a few more lines of code. Code: Node* kReverse(Node* head, int k) { int cnt = 0; Node* curr = head; Node* prev = nullptr; Node* fwd = nullptr; while (curr!=nullptr && cnt < k) { fwd = curr->next; curr->next = prev; prev = curr; curr = fwd; cnt++; } //You need to add this; Note: I have used the variable name fwd instead of next. if(cntnext = prev; prev = curr; curr = fwd; cnt++; } } //Till here if(fwd != nullptr){ head->next = kReverse(fwd, k); } return prev; }

[@tjstar390]

Thank you bhaiya for giving fabulous content as both Question are very easy to understand.

[@pushkarchaubey8300]

bhut badhiya vedio tha bhaiya mazza aa gaya ekdamm mst smjh me aaya LL

[@saiyamanand1387]

Maaza aa rha hai karke coding ab bohot sahi chl rha hai sab jaldi jaldi bna do Bhaiya video ab

[@aryanrathi1843]

After surfing many other youtube vedios , I watched this Vedio and the explaination of the first question in the vedio told by bhaiya is crystal clear. Crazyy!! and thanks for this kind of in-depth explaination it became like an very easy problem for me now.

[@parassetia4964]

Lec 46 done...consistency op

[@kaushalkumar01]

Thanks bhaiya....mza aa gya🔥🔥🔥🔥 Aapki yhi consistency hi to motivation hai hmare liye... Aise hi vids bnate rho bhaiya💜

[@srajittanwar636]

PRESENT BHAIYA ,aap bhi josh high rakho humara bhi high h

[@ln-gamer9496]

BHAIYA YOU ARE MY BEST TEACHER

[@code___with___me]

in this question one case is missing like if the K is greater then the no. of elements in the linkedlist so we also need to count the elements in the linked list and have to made a condition that if(k>no. of elements in the linkedlist )then we will return head Node* kReverse(Node* head, int k) { if(head==NULL){ return NULL; } Node* prev=NULL; Node* forward=NULL; Node* curr=head; //checking whether the size of k is smaller then the size of the linkedlist int counter=0; Node* temp=head; while(temp){ temp=temp->next; counter++; } int count=0; if(k>counter){ return head; } while(curr && countnext; curr->next=prev; prev=curr; curr=forward; count++; } if(forward){ head->next=kReverse(forward,k); } return prev; }

[@vikramlucky92]

you can add another case to this part for little improvement: while(temp and counter < k){ temp=temp->next; counter++;

[@ThePrajaktaVlogs]

dekh rahe hai bhaiyya ! aur maja bhi aa rha h : )

[@culeinfo3058]

yes keep uploading daily. love ur content

[@makkar.ankush]

code for submission without errors regarding lenght less then k ``` Node* kReverse(Node* head, int k) { //base call if(head == NULL) { return head; } //step1: reverse first k nodes Node* next = NULL; Node* curr = head; Node* prev = NULL; int count= 0; // *ADDITIONAL CODE* // check if k nodes are available int check= 0; Node* Chk = head; while( Chk != NULL && check < k ) { Chk = Chk->next; check++; } // if not available then return head without reversing if(check != k){ return head; } // else reverse while( curr != NULL && count < k ) { next = curr -> next; curr -> next = prev; prev = curr; curr = next; count++; } //step2: Recursion dekhlega aage ke nodes ko // aur usko jod do pehle vale k sath if(next != NULL) { head -> next = kReverse(next,k); } //step3: return head of reversed list return prev; } ```

[@scoc55vora15]

Very Detailedfully Explained Bhaiya on the Entire youtube

[@RohitRana-tz2lr]

Thanks bhaiya for your videos... crossed 50 videos... consistency++... mja aara h bhaiya

[@nikhildhiman0714]

Bhiya apka motivation high h tabhi Mera bhi . App 3 video bno ge ma 3 hi dakh luga🥰🥰🥰

[@shashnka]

haaaaard love bhai watched till end🗣🗣

[@ellis-pr7hh]

i wish and hope that your channel will grow more faster and aapka dsa course best dsa course over youtube consider kiya jaya (though i already consider that bt this course needs to be reached to lot of people) thank you for this course>>

[@rajatjana]

For Leetcode: class Solution { public: ListNode* reverseKGroup(ListNode* head, int k) { if(head==NULL){ return NULL; } ListNode* next=NULL; ListNode* curr=head; ListNode* prev=NULL; int c=0; while (curr != NULL && c< k) { curr = curr->next; c++; } if (c < k) { return head; } curr = head; c = 0; while(curr!=NULL&&cnext; curr->next=prev; prev=curr; curr=next; c++; } if(next!=NULL){ head->next=reverseKGroup(next,k); } return prev; } };

[@nana_patekar_]

we can also solve circular LL question using Floyd's cycle detection bool isCircular(Node* head){ // Write your code here. //if head is NULL if(head==NULL) return true; //ony 1 node if(head->next==NULL) return false; Node *fast=head; Node *slow=head; while(fast->next!=NULL){ fast=fast->next; if(fast!=NULL) fast=fast->next; slow=slow->next; if(fast==slow && fast ==head) return true; else if(fast==slow && slow!=head) return false; if(fast==NULL){return false;} } return false; }

[@RitikSingh-oh3sj]

bhaiya iss lecture mai maga aa gaya bhaiya kaya mast code tha bahiya

[@computerguy3550]

Thanks Alot bhaiya Ek Number Content👌👌👌👌

[@prathammadhani4372]

Attendance marked....thanks bhaiya for love babbar contest 4

[@RahulKumar-wt9qc]

Video banaiye love bhaiya hum log dekh rahe hai ❤️❤️👍👍

[@krishnendubanerjee8523]

What if the list is: 1,2,3,4,5 and k=3. This approach won't work. Output should be: 3,2,1,4,5. But it will give you: 3,2,1,5,4

[@karankaran1916]

you can compare the length with k at start

[@kunalboxer4432]

It will work try trail run

[@sukhendubanerjee5082]

​@@karankaran1916 but on calculating the rest part of LL we want to use loop then what will be the time complexity? Plzz explain and what will be the code ...

[@anmol3]

​@@karankaran1916 thanks bro

[@meghaiiitd4586]

You can count the remaining elements from current, ListNode* remaining=curr & count=0; then if count>=k (recursion) else head->next=curr.

[@Josuke217]

map can also be used , if freq of a node is 2 then it's circular linked list.

[@Harshji249]

Great video for linked list question

[@manojalladawar2262]

Done wih previous lecture and i'm with your phase. Full dedicate hai thanks for this amazing series. Thank you bhaya.

[@bheemsingh-fh1zu]

Bhaiya please daily video laado🥺🥺 Placement aapke bharoshe h. Mujhe aapse hi pdhna h😁

[@sanskritiagrawal5960]

Bhaiya bas aise hi padhao bhot sahi chal raha h

[@anushreepaul5308]

raat ke 01.38 baj rhe hai.. still mai code kar rhi.. because of you vaiya.. 😁😁 Thank you sooo much :)

[@arjunyadav-kt5jr]

V kyu lagate ho be tumlog, bh ki jagah pe?

[@gouravmuchhal1985]

i dont know how he breakdown things in so simple ..

[@akash.vishwakarma]

For those who don't have to reverse when length < k int getLength(Node* head) { int length = 0; while(head != NULL) { count ++; head = head -> next; } return length; } Node* kReverse(Node* head, int k) { if(head == NULL || head -> next == NULL) { return head; } if(getLength(head) < k) { return head; } Node* prev = NULL; Node* curr = head; int count = 0; while(curr != NULL && count < k) { Node* forw = curr -> next; curr -> next = prev; prev = curr; curr = forw; count ++; } head -> next = kReverse(curr, k); return prev; }

[@iEntertainmentFunShorts]

Completed this lecture also aap jab circular list wala bta rhe thy toh mere mind m aaya tha ki yei loop bhi ho sakta h yaha pr (mtlb logic bnna start ho gya h bhaiya ) then Floyd's ka toh pta ni muje but hash map se solve ho jayega woh...Floyd's dekhuga ab sayad graph m Maine warshall , Dijkstra and Floyd's pdi h wahi hogi...

[@amarnathprajapati2543]

39:58 Bahut energy hai Sirji😂😂

[@mananupmanyu5440]

Updated code for reverse K nodes on @leetcode 30/30 test cases passed Node* kreverse(Node* &head,int k) { // base case if(head == NULL) { return NULL; } Node* curr = head; Node* prev = NULL; Node* forw = NULL; int cnt = 0; while( curr != NULL && cnt < k){ forw = curr->next; curr -> next = prev; prev = curr; curr = forw; cnt++; } // if the forward list's length is less than k than we simply // join the original list to the head if(getlength(forw) < k){ head->next = forw; } else if (forw != NULL && getlength(forw) >= k){ head -> next = kreverse(forw,k); } return prev; }

[@priyanshusahoo8266]

We can also use concept of two pointers to check the circular LinkedIn list

[@devsood12]

updated solution for Q1 int sizeLL(Node *head) { Node*temp = head ; int cnt = 0 ; while (temp !=NULL ) { cnt ++ ; temp = temp->next ; } return cnt ; } Node* kReverse(Node* head, int k) { // Write your code here. int size = sizeLL(head ) ; Node * prev = NULL ; Node * curr = head ; Node * next = NULL ; int cnt = 0 ; if ( head == NULL || head -> next == NULL || k == 1|| size < k) { return head ; } while (curr!=NULL && cnt < k ) { next = curr->next ; curr->next = prev ; prev = curr ; curr = next ; cnt ++ ; } if (next != NULL ) { head->next = kReverse(next, k) ; } return prev ; }

[@DILSHADKHAN-cv1qw]

for cll: bool checkcircular(Node *head) { if(head==NULL) //empty list return 1; Node *temp=head->next; while(1) { if(temp==head) return 1; if(temp==NULL) return 0; temp=temp->next; } }

[@111rhishishranjan2]

while (1) mean ??????

[@DILSHADKHAN-cv1qw]

@@111rhishishranjan2 infinity loop (always true)

[@jatingarg1897]

Dekhte Dekhte video bhai itni aage pahunchgaye ! :)

[@absarahmad8625]

Bhaiya becuase of uh finally i learn how to think how to improve logic. thnx bhaiya

[@bhavingargyt]

dekh rhe hai sir abhi bhi or khatam karke hi rahunga .... 🌟

[@aparnamanna1369]

Attendance marked , chalo lecture dekh te hai

[@rawat_ji5183]

nice explanation bhaiya easy to understand 😁😁

[@somesh1934]

Present Bhaiya..... And thanq bhaiya but bhaiya aap ek he video daalo ek din ki kyonki doosri studies bhi rehti hai for example agr me meri he baat krun toh me python full stack k liye react,django vgera bhi pd rha hn toh mujhe unki bhi practice krna hoti hai toh load bht bd jata hai but haan first priority aapke liye hain then python full stack k liye so bhaiya bus.....Me toh mere point of view se bta rha hn jo baaki dusro ko accha lge ek din ki kitni video? majority wins.... And thanq so much bhaiya for the video....Waiting for the next video.....

[@be_happy8411]

bhayia main aaj k aaj ll khtm krna chahta hoon , currently 3 videos dekhli hain ab 4th start krne wala hoon. Motivation bnaye rkhne k liye aage ki hr video complete krke comments mein aapko msg kroonga 🥲, btw boht badhiya padha rhe ho aap😀👍

[@Bhagwati_Jewellers.]

Bhaiya mjaa aa rha h 🙌

[@rpgaming757]

Thanks bhaiya , this video is very helpfull for me

[@suranjandhara7535]

Aa gya hu bhaiya...... Present bhaiya 🤗🤗🤗🤗🤗🤗 Kal contest hai.....Accha nhi hoga pata hai... Firbhi dunga...😔😔😔😔😔😔 1 week follow kar raha hu bhaiya...🤗🤗🤗🤗🤗🤗🤗🤗😊😊😊😊😊 Love you bhaiya.... Amazing 😍😍😍😍😍 content

[@adityasahoo506]

My Solution : whenever length>k from there we call a function to calculate remaining length. if remLenght>=k then we use recurrsion. otherwise just add head->next to curr ; class Solution { public: int calc(ListNode* curr){ int count = 0 ; while(curr!=NULL){ count++; curr = curr->next; } return count; } ListNode* reverseKGroup(ListNode* head, int k) { int length = 0 ; ListNode* prev = NULL; ListNode* curr = head ; ListNode* next = NULL; while(lengthnext; curr->next = prev ; prev = curr ; curr = next ; length++; } head->next = curr; int remLength = calc(curr); if(remLength >= k ){ head->next = reverseKGroup(next , k ); } return prev; } };

[@04adarshsingh47]

your way of explanation is really Good ❤

[@abhishekjha0303]

Nice explanation bhaiya!

[@Shantanu_Jod]

Following The course! 😄

[@dewanshyadav6033]

Thanks bhaiyya 🙏🙏🙏🙏...

[@AnuMessi10]

Do not stop bhaiya, lecture 37 par hu, will catch up soon

[@sachin_singh_tomar_]

bool isCircular(Node *head) { Node* temp = head->next; while(temp){ if(temp==nullptr){break;} if(temp==head){return true;} temp=temp->next; } // Your code here return false; }

[@balwantyadav724]

Nice explanation Bhaiya

[@DheerajKumar-td5ts]

Thank you bhaiya

[@srinathsilla5800]

Keeping up with the videos 👏🙌

[@nikunjpadia2970]

Great Explanation Understood Everything.

[@Divyansh-x7n]

bhot hard content bhaiyaaaaa >>>>