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 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
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 !!!
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
coding it piece by piece after each illustrated/explained block was a great idea. thank you!
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.
You really deserve heaven, good man! Thanks so much for doing this. A donation is totally well deserved!
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
Very good illustration and idea. I feel I will never be able to solve this within a normal coding interview session by myself
Breaking it into 3 parts helped a lot. Thank you
great explanation! this problem seems easy, but it's really tricky
Coding while explaining was a great idea and more understandable, kindly follow the same pattern for further videos!
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 are awesome, dude. Thanks for such clear explanations!
Thanks, happy it's helpful!
Amazing explanation again, that trick of adding dummy node really helped.
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.
I am simply amazed by the clear explanation! Just simply wow...Thank you so much
Great code, as usual! Commenting the code like this is also helpful.
you motivate me to solve problem everyday man
Keep up the good work 💪
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
Your explanations on these problems helped me a lot! Thanks for all the hard work that went into making these videos.
Thanks for such clear explanations! Love from Bangladesh
Best video explanation for it... thnx for the effort 😇
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
wonderful explanation
I had solution idea like that, but could not implement properly. So thanks very much for that.
thank you soo too much this I much cleaner and easy to understand and probably will never forget
It looks easy but when it comes to write a compilable code in interview there are good changes of making mistake.
Thanks for this bro
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?
Linked List problems aren't hard but they're confusing af
Easy to get lost
Thanks for the clean illustration. ^_^
Those who can reverse a Linked List, they can easily solve this.
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
Awesome man!!! Thanks for this.....
Great video, thanks!
Thanks bro very much!
Great video!
Thank you so much sir
Thanks man
thanks ! :D
so smooth!!!
best solution😌
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.
Hey can you please do 'create BSt from levelorder array' problem.
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
This code is way harder to write than what appears at the end of this video.
whatif i use a arraylist to swap
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
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
Thanks!
⌘⌘ AMAZING ⌘⌘