Hey, for visual problems like this would you consider Leetdebug - th-cam.com/video/lXWgPCYDfMc/w-d-xo.html as being something worth integrating in NeetCode ? I have gotten some good feedback on this project from people - but integrating it in NeetCode would be a dream come true as it could potentially help the community quite a lot. What do you think ?
For those who find this problem chanllenging, you are not alone. This is still by far the best explanation for this problem. Highly encourage you to hang in there, pause the video multiple times, understand it, take a break and come back to it. It will eventually make sense, as long as you don't give up and show up to understand it.
bro i m confused : if in case left is at 1st index then dummy.next points to head i.e. first node but answer would be right if leftprev.next is returning
i thought of the same idea but wasnt able to write a code properly as i got really confused, the solutions i tried to read on leetcode confused me even more
I like this style of explaining where you go back and forth between the drawing and the code. It helps me mentally map the concept directly to implementation
for anyone having issue in this solution try first solve reverse linked list 1 and then come up with this to solve...It is really easy to understand when you know the previous question..and Thanks once again to Neetcode for helping me out.
Very clever handling of the edge cases: 1. If we are reversing the last n nodes, the last node after reversing will point to null as expected as cur would be null 2. If we are reversing the first n nodes, we have a leftPrev node thanks to dummy. leftPrev.next would point to the right node and when we return dummy.next that is essentially the right node
ollie mollie man, this is such a great explanation, you've got such a talent to convey information. Congrats on the job, well deserved. I myself got interviews lined up pretty much with all of FAANG and your videos are my go-to source when I want to just sit and watch something rather than practice hands-on coding.
Another way to think about the very first part of this algorithm is: "Until current.val is L, move the prev/curr pointers up". I found this to be a more intuitive way of thinking than the (left - 1) approach here (YMMV). Similarly, in the second phase of the algorithm, instead of thinking about indicies you can just think about it like this: "Reverse the list, once prev.val = R you, you know you're done reversing the sublist." I find the less I can think about indicies the more high-level I can think about the algorithm.
More readable code: # Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): # self.val = val # self.next = next class Solution: def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]: dummy = ListNode() dummy.next = head prev, cur = dummy, head for _ in range(left - 1): prev = cur cur = cur.next left_prev, left_node = prev, cur prev, cur = None, left_node for _ in range(right - left + 1): tmp = cur.next cur.next = prev prev = cur cur = tmp right_node, right_next = prev, cur left_prev.next = right_node left_node.next = right_next return dummy.next
Thank you for the explanation! However, for 1 test case the given list is [1,2,3,4] 1,4 my output is [4,2,3,1], but the expected output is [4,3,2,1] Could you please tell me where I'm lacking? I'm using two pointer method in python
really helpful man, you are motivating me to work on more problems everyday thanks a million. but can you come up with the Follow up: Could you do it in one pass?
Here is my Java solution, it's failing for [5] 1 1 . How do you handle this case? public ListNode reverseBetween(ListNode head, int left, int right) { // 0. ass dummy node at start this helps in hadling edge cases // if left is head itself etc. ListNode dummy = new ListNode(0, head); // dummy.next = head; // 1. Iterate till you find leftNode, remeber prevLeft (iterate left-1) ListNode leftPrev = dummy; ListNode curr = head; while(curr!=null && curr.val
@@anushab.v.8512 Guess I'm really late, but why are you checking for value? Value of node has nothing to be with anything here. Maybe that's why you are failing the test case
Does anyone know how I can fix the below code, I would appreciate help. I tried to solve it based on the solution for reverse node in K group. dummy = ListNode(0, head)
# Connect the reversed segment back into the list prevlef.next = prev left_node.next = right_node.next return dummy.next def getKth(self, k, curr): prev = None while k > 0: prev = curr curr = curr.next k -= 1 return curr, prev
Thanks for great explanation. Just want to give one feedback - while explaining you are writing too many color markings which can be avoided. second - coding can be written much understandable format for other language people. you writing deep python code like merging multiple statements into one.
Well, that's a very subjective thing. Here is my feedback: Color markings are great, and really help to visualise the solution. Different colors for pointers, values, nodes, edges between nodes, it makes everything so much easier to follow and understand. I don't have Python in my arsenal, but I love it for the purposes of these tutorials. I can clearly understand each line of code, there is no black magic in there, and it would much more verbose in most other languages, which would take more time and potentially confuse viewers.
💡 LINKED LIST PLAYLIST: th-cam.com/video/G0_I-ZF0S38/w-d-xo.html
thanks
Thanks for your explanation, it helps me a lot !!!
Hey, for visual problems like this would you consider Leetdebug - th-cam.com/video/lXWgPCYDfMc/w-d-xo.html as being something worth integrating in NeetCode ? I have gotten some good feedback on this project from people - but integrating it in NeetCode would be a dream come true as it could potentially help the community quite a lot. What do you think ?
For those who find this problem chanllenging, you are not alone. This is still by far the best explanation for this problem. Highly encourage you to hang in there, pause the video multiple times, understand it, take a break and come back to it. It will eventually make sense, as long as you don't give up and show up to understand it.
bro i m confused : if in case left is at 1st index then dummy.next points to head i.e. first node but answer would be right if leftprev.next is returning
came back after sometime and I understand it fully.
@@memesbyanony it's literally explained at 05:23
i thought of the same idea but wasnt able to write a code properly as i got really confused, the solutions i tried to read on leetcode confused me even more
coding it piece by piece after each illustrated/explained block was a great idea. thank you!
Your explanations on these problems helped me a lot! Thanks for all the hard work that went into making these videos.
It brings me an immense relief whenever I'm facing an issue understanding a LeetCode problem and I find you have a video for it.
I like this style of explaining where you go back and forth between the drawing and the code. It helps me mentally map the concept directly to implementation
Dude, I have nothing but admiration for how you approach various problems. Every time you do it clear, simple and smooth.
Very good illustration and idea. I feel I will never be able to solve this within a normal coding interview session by myself
for anyone having issue in this solution try first solve reverse linked list 1 and then come up with this to solve...It is really easy to understand when you know the previous question..and Thanks once again to Neetcode for helping me out.
Very clever handling of the edge cases:
1. If we are reversing the last n nodes, the last node after reversing will point to null as expected as cur would be null
2. If we are reversing the first n nodes, we have a leftPrev node thanks to dummy. leftPrev.next would point to the right node and when we return dummy.next that is essentially the right node
Coding while explaining was a great idea and more understandable, kindly follow the same pattern for further videos!
Breaking it into 3 parts helped a lot. Thank you
Great video only thing that got me was the edge cases. Very clever to use the dummy node, You could say it was some NeetCode.
You really deserve heaven, good man! Thanks so much for doing this. A donation is totally well deserved!
Great explanation as always. Wonderful skills to break down the problem and starting to solve it!
great explanation! this problem seems easy, but it's really tricky
ollie mollie man, this is such a great explanation, you've got such a talent to convey information. Congrats on the job, well deserved. I myself got interviews lined up pretty much with all of FAANG and your videos are my go-to source when I want to just sit and watch something rather than practice hands-on coding.
did you get the job?
@@leeroymlg4692 yeah I did
Another way to think about the very first part of this algorithm is: "Until current.val is L, move the prev/curr pointers up". I found this to be a more intuitive way of thinking than the (left - 1) approach here (YMMV).
Similarly, in the second phase of the algorithm, instead of thinking about indicies you can just think about it like this: "Reverse the list, once prev.val = R you, you know you're done reversing the sublist."
I find the less I can think about indicies the more high-level I can think about the algorithm.
More readable code:
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
dummy = ListNode()
dummy.next = head
prev, cur = dummy, head
for _ in range(left - 1):
prev = cur
cur = cur.next
left_prev, left_node = prev, cur
prev, cur = None, left_node
for _ in range(right - left + 1):
tmp = cur.next
cur.next = prev
prev = cur
cur = tmp
right_node, right_next = prev, cur
left_prev.next = right_node
left_node.next = right_next
return dummy.next
you motivate me to solve problem everyday man
Keep up the good work 💪
I am simply amazed by the clear explanation! Just simply wow...Thank you so much
you are awesome, dude. Thanks for such clear explanations!
Thanks, happy it's helpful!
Amazing explanation again, that trick of adding dummy node really helped.
Best video explanation for it... thnx for the effort 😇
Great code, as usual! Commenting the code like this is also helpful.
Thanks for such clear explanations! Love from Bangladesh
Thanks!
brooo i did it on my own using recursion and it works... i am finally seeing some progress 😭😭😭😭😭
I had solution idea like that, but could not implement properly. So thanks very much for that.
Thank you for the explanation! However, for 1 test case the given list is [1,2,3,4] 1,4
my output is [4,2,3,1], but the expected output is [4,3,2,1]
Could you please tell me where I'm lacking? I'm using two pointer method in python
really helpful man, you are motivating me to work on more problems everyday thanks a million.
but can you come up with the Follow up: Could you do it in one pass?
thanks for explaining!
It looks easy but when it comes to write a compilable code in interview there are good changes of making mistake.
wonderful explanation
thank you soo too much this I much cleaner and easy to understand and probably will never forget
Those who can reverse a Linked List, they can easily solve this.
Thanks for this bro
bro you're so smart!
I use Java but this is very helpful! Thank you!
Here is my Java solution, it's failing for [5] 1 1 . How do you handle this case?
public ListNode reverseBetween(ListNode head, int left, int right) {
// 0. ass dummy node at start this helps in hadling edge cases
// if left is head itself etc.
ListNode dummy = new ListNode(0, head);
// dummy.next = head;
// 1. Iterate till you find leftNode, remeber prevLeft (iterate left-1)
ListNode leftPrev = dummy;
ListNode curr = head;
while(curr!=null && curr.val
@@anushab.v.8512 Guess I'm really late, but why are you checking for value? Value of node has nothing to be with anything here. Maybe that's why you are failing the test case
Thanks bro very much!
Awesome man!!! Thanks for this.....
Thank you so much sir
Great video!
if r = 4 then shouldn't the element at 4th index be 5? 'cuz the index starts from 0?
Given in the question that "l" refers to 2nd index, implying index reference as 1 being the first node.
Linked List problems aren't hard but they're confusing af
Easy to get lost
Great video, thanks!
Thanks for the clean illustration. ^_^
best solution😌
i used stack for this problem
Thanks man
Hey can you please do 'create BSt from levelorder array' problem.
thanks ! :D
Does anyone know how I can fix the below code, I would appreciate help. I tried to solve it based on the solution for reverse node in K group.
dummy = ListNode(0, head)
# Get nodes
left_node, prevlef = self.getKth(left, dummy)
right_node, _ = self.getKth(right, dummy)
# Reverse the segment
prev, curr = None, left_node
while curr != right_node.next:
tmp = curr.next
curr.next = prev
prev = curr
curr = tmp
# Connect the reversed segment back into the list
prevlef.next = prev
left_node.next = right_node.next
return dummy.next
def getKth(self, k, curr):
prev = None
while k > 0:
prev = curr
curr = curr.next
k -= 1
return curr, prev
so smooth!!!
whatif i use a arraylist to swap
This code is way harder to write than what appears at the end of this video.
This problem is more obnoxious than it is challenging
FIRST FIND AND UNDERSTAND HOW TO REVERSE A LINKEDLIST IN-PLACE, AFTER IT WILL BECOME WAY MORE EASIERR PROMISEE
Time execution is slow
Thanks for great explanation. Just want to give one feedback - while explaining you are writing too many color markings which can be avoided. second - coding can be written much understandable format for other language people. you writing deep python code like merging multiple statements into one.
Well, that's a very subjective thing. Here is my feedback:
Color markings are great, and really help to visualise the solution. Different colors for pointers, values, nodes, edges between nodes, it makes everything so much easier to follow and understand.
I don't have Python in my arsenal, but I love it for the purposes of these tutorials. I can clearly understand each line of code, there is no black magic in there, and it would much more verbose in most other languages, which would take more time and potentially confuse viewers.
simpler solution
class Solution:
def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
slow,fast = head,head
meet = head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
if slow == fast:
break
else:
return None
while meet != slow:
slow = slow.next
meet = meet.next
return meet
Did you post in the wrong video?
Floyd's algo serves a diff purpose. i think u posted this in the wrong video mate.
tf
⌘⌘ AMAZING ⌘⌘