LeetCode Palindrome Linked List Solution Explained - Java 

Odd-numbered items example Say the original list is 12321. After iterating through slow and fast: Slow -> 321 After reversing slow: Slow -> 123 Reset fast to head However, note that the state of the original list is now: fast->1->2->32->3 BUT 1->2->3

Maybe you can put the camera window to the right top corner? It blocked the code.

0:01, that slapping which every Nick White video starts with.

I have been watching a lot of the videos that you posted on solving leetcode problems, cuz i have no idea how to do a lot of them on my own, lol. Just want to say thank you for spending the time to make these videos and posting them on youtube, it really helps!!!

Great Man! You are literally helping the community a lot. Keep it up!

Thank you Nick!! Really good explanation!!

Thanks for this tutorial, i just didnt understand why you needed to go to half of the array. But once you reverse it, it all makes sense.

great explain .. keep up the good content .. I think you should also put a pointer to the camera window and iterate it to the left corner

Awesome explanation! Thanks Nick

Hey you explained it really nice could you load more problems.

My Goal for this year is to solve all the leetcode problems you have done here. Your channel is the first place I refer to if i am stuck solving LC.

awesome explanation nick

We can also make a copy of the original list, reverse the list and then compare the original list and the reverse list using a loop ..

Thanks so much for all🍀

very good stuff Nick, this is extremely helpful. and dont worry none of us CS guys are good at explaining, you're doing good.

nice one!! but, try to provide the source code as you're window always blocks the screen

When there is a odd length linked list, we should not compare the middle element with anything. For ex: 11211 is a palindrome and the value "2" which is a middle element shouldn't be a part of the comparison logic. This logic needs to be added here.

Great job

bro, can u share the code? the camera window blocked the code

is it possible to start posting ur code on git?

wow, this solution is so genius. Algorithms are fun

Your camera window is blocking the code. Can you move it?

Love your videos

Thanks!! Awesome solution. Could you also use a stack to reverse the order of the first half and compare the second half to the "popped" value, rather than reverse the list?

Basically, i copied the same concept and wrote in python, the submission was wrong. However when i wrote the same thing in java, it accepted

Thanks a lot

Bro you’re such a coding gangsta 😎 I hope I will be able to at least THINK of the logic before writing the code.

I didn't see the reverse bit so I wrote my own code. But thanks for the solution!

Thanks for covering most of the code with your image 🙂

I wrote similar code in c++ it shows better than only 23.44 percent ! Why so ?

when the slow pointer gets to 3, where would the faster pointer be, null?

For those who cant see last function :) public ListNode reversed(ListNode head)

i mean personally i will traverse the linked list and store the values in an array and then reverse the array and make it a string and integer and compare both arrays or so ...although it might be slower

would not it be easier to copy the original linked list and reverse it, then compare the two?

suggestion-> YOU CAN USE WHITEBOARD TO EXPALINA ND THEN CODE

oh lord,I took queue data structure to put given list into queue,then i reversed the list and iterated through each node checking if val are equal or not.

Hi Nick, Your work is truly appreciated, I learned a LOT from your content. I find that your approach to presenting information is in line with my own way of thinking, making you the ONLY RU-vidr who has been able to resonate with me in this manner. Since this question is super important and it is frequently asked, can we discuss a better solution than this? Although it is accepted by LeetCode, the interviewer would say that my Linked List got broken, I could offer to re-reverse the second half and put the list back together. But the interviewer would further note that the proposed solution is not suitable for a concurrent environment, where multiple threads or processes may concurrently access the same data. And for sure, one potential disadvantage of modifying a Linked List is that it can temporarily disrupt the structure of the list, which can cause issues if other threads or processes try to access the list at the same time. One answer to avoid such issues can be to use locks or other synchronization mechanisms to ensure that only one thread or process can access the list while it is being modified. But the interviewer will confirm that this can add additional overhead and complexity to the code. SUMMARY: a nightmare :D Can you discuss O(1) space complexity other than modify the list in place? I would much appreciate it if you get back to me. Best, Nataša

odd number of elements then we need to increase slow = slow.next right? before we reverse

thanks bro greeting from INDIA

and what about the linked list which are of odd length like 1-2-1. should't it be while(fast!=slow && slow!=null) on line 29????

its failing for 1->0->1

i am finding this problem really difficult. Though i see it listed as Easy in leetcode :(

it may be possible by using stack? //.....

your camera window is blocking the code

bro why is this problem in the easy category

Will this work for 1->2 ? I think it needs minor modifications.

omg the new mic

idk about this some 3 years before but now this solution is showing TLE :

what if the number of nodes is odd ?

I might be over simplifying this, but couldn't we just store each value in the LinkedList in an ArrayList (in order), call Collections.reverse() and save it as a new ArrayList, and then compare the two lists?

Good video man but what the hell your whole potshot is blocking the bottom part of the code man.. jeez

why this code shows TLE. Thanks in advance. class Solution { public boolean isPalindrome(ListNode head) { String s1,s2; s1 = ""; s2 = ""; while(head != null) { s1+=String.valueOf(head.val); s2=String.valueOf(head.val)+s2; head = head.next; } return s1.equals(s2); } }

Definitely a medium problem

Why isn’t a tail here?

Why not just reverse the linked list then run through the length of the original and reversed list comparing as you go? Both values have to be identical for it to be a palindrome.

you should have been loud to understand what you saying

its failing for 1->0->1 As after first while loop the slow = 0 so then fast = 1 1!=0 return false but 101 is a palindrome

This solution is convoluted and includes recursion, which is not accepted by big tech companies. There is no reason to reverse half. Instead, stick the first half in a stack, then compare the second half to the entries in the stack.

Why not to use a 2 pointer technique? You just run to the end with b pointer and then compare the elements. a+ + b- - Need to adjust stop condition but it seems to me easier.

It destroys the structure of the linkedlist. Not a good appraoch when working on practical projects.

Should've just used a visualization.

Coding Skills: 10/10 Teaching Skills: 3/10

ANY Indian channel will explain more clearly than this guy.

your video is hiding the code :)

the vid hiding the most important part of the code is torturing me