This is great video! but, I feel the algo provided in the end is not the same as the way he was explaining.. I went ahead and wrote my code for it same way he explained: ``` class Solution: def sortArray(self, nums: List[int]) -> List[int]: def quicksort(nums, lo, hi): if lo < hi: partition_resting_point = partition(nums, lo, hi) quicksort(nums, lo, partition_resting_point - 1) quicksort(nums, partition_resting_point + 1, hi) def partition(nums, lo, hi): pivotIdx = random.randint(lo, hi) nums[pivotIdx], nums[hi] = nums[hi], nums[pivotIdx] pivot = nums[hi] l_idx = lo r_idx = hi-1 while l_idx
Yeah, in the early days I didn't spend enough time on pseudocode. Trying to fix that now by building out this repo: github.com/msambol/youtube/blob/master/sort/quick_sort.py. Thanks for the feedback!
After you swap itemFromLeft and the pivot at the end, itemFromLeft is now at the end of the array. So, use that as the *new* pivot. Repeat that until its sorted.
@@kennethquilantang8080 after 7 is put in its correct position, remember that all numbers to the right of 7 are greater than 7. In this case, there is only one number - 8. A partition with just one number is already sorted, so you can ignore it and move on to sort [6,5] to the left of 7. For sorting [6,5] choose 5 as the pivot. itemFromLeft is therefore 6, and itemFromRight has no value because no number in the array smaller than 5. Therefore, we can stop and swap itemFromLeft and the pivot to leave [5,6]. Yes, the video is unclear because it does not explain these cases. The point is that each time you put the pivot into it's correct position, you have "split" the array into two parts - one part has all numbers bigger than the pivot and the other part has all numbers smaller than the pivot. Parts with *just one* element are already sorted. If a part is already sorted, no itemFromLeft can be found. If a part is unsorted, you are guaranteed to find an itemFromLeft, and if the index of itemFromRight < the index of itemFromLeft *OR* itemFromRight does not exist then you can swap itemFromLeft and the pivot to put the pivot into its correct position in the whole array.
To ones without enough background knowledge, this video omits details of execution of each step. But to ones with, this is concise and covers sufficient key points of quick sort. Thanks a lot for your video sharing.
N Betancourt cuz the way he explains it IS confusing I’ve watched this a couple of times, thought I understood went to the exam and screwed up Now that I’ve watched other videos I understand that the way he explains it is confusing
He didn't explain what quick sort does in general, what it can be applied to, and left some holes in the explanation that someone with no experience would struggle to grasp. Which is a shame.
I've been looking at it for a few minutes now, and I can believe that this pseudocode is accurate, but I'd have to check the details of what the partition function is doing to be sure, but it seems legit. Assuming your language of choice will permit a self-referential function like that.
@@diabl2master The recursion is fine... he's talking about how `partition` is putting the pivot on the left wall instead of the right. In the video the pivot is on the right side.
@@jscholex That would be a failure of technically reflecting, not intuitively reflecting, the walkthrough. I'm not sure OP was referring to that, but who knows.
If anyone is confused at the 1:10, basically he doesn't go through the loop. Instead he jumps to when item from left is higher or item from right is smaller etc. There is a left and right pointer that checks for the condition and then left++ or right-- if its not correct. itemsfromRight goes from 1 cuz its smaller, and then the right-- checks 7, not smaller, right--, checks 8 not smaller, right-- and then it checks the 0 and see that its smaller.
I study computer science, and once, I had an exam with a few sort algorithms in it. I didn't really study but about twenty minutes before the exam I watched your 2-4 minute videos on these sort algorithms and I passed the exam. Thank you for helping me.
This is great. The simple explanation and the especially simple pseudocode towards the end makes it easy to understand the core concept of the algorithm.
Thank you so much, i have a pc science test today, and i didn'T understand since i can't speak german that well and i am still learning it, this guy explained it all
thank u so much, i have an exam tommorow and was stressing bc i couldnt figure out how quick sort work with my teacher's explanation and this just simplified it easily. tysm ;-;
I watched several videos, including my school books, and I had no idea what they were saying with left to right and could not get the answers in the correct order because of that. I was able to understand after watching your video and it allowed me to get past my assignment. Thank you.
Thank u very much Sir, I got it completely. Actually I'd missed my college online lecture b/c of sleeping... U saved me just night before exam, as urs is the shortest video on YT.
The video explains the concept of quicksort, a recursive algorithm used for sorting arrays. It emphasizes the importance of choosing a pivot and demonstrates the process of partitioning the array. The video also mentions the pseudocode for quicksort and discusses its time complexity. Understanding Quicksort Algorithm 00:00 Quicksort is a recursive algorithm that uses a pivot to sort an array. 00:13 The pivot is placed in its correct position, with smaller items to the left and larger items to the right. 03:24 Choosing the pivot properly is crucial for the performance of the algorithm.
Hey, Thanks for the explanasion, It was a clear and concise video, however the pseudocode is somewhat wrong I believe in 3 things: In Partition, the order of operations is not correct: increment leftwall first, then swap. The final swap in Partition is not correctly swapping the pivot's original position with A[leftwall]. The recursive calls in Quicksort should be updated to exclude the pivot_location from the ranges, properly dividing the array into segments that exclude the sorted pivot. here is the corrected version: Quicksort(A as array, low as int, high as int) if (low < high) pivot_location = Partition(A, low, high) Quicksort(A, low, pivot_location - 1) Quicksort(A, pivot_location + 1, high) Partition(A as array, low as int, high as int) pivot = A[low] leftwall = low for i = low + 1 to high if (A[i] < pivot) then leftwall = leftwall + 1 swap(A[i], A[leftwall]) swap(A[low], A[leftwall]) return(leftwall) Thanks again!
The pseudocode is hard to read, but the variable name "leftwall" is really good, this gives me a vivid concept of how the leftmost larger item was swapped and the "wall" moved.
@@blurryhorizon I suppose that in the Partition function, the "pivot = A[low]" should actually be "pivot = A[high]"? Very confusing so I wrote it down and found out that the pseudocode doesn't work properly. // Oh just realised that although pivot = A[low] might works as well but the pseudocode is totally wrong for Partition function jeez..
I really like this explanation. This moves the pivot out of the way and swaps it back with the itemFromLeft pointer. That's so much easier than some other videos I've seen where the pivot is in the middle of the action and we're confused with >= or
I guess, In the quicksort explanation he moves the pivot to the RIGHT END of the array. In the pseudocode, he moves the pivot to the LEFT end of the array. And after the swapping is done, he then brings the pivot to the original position from the LEFTEND. I've seen too many quicksort algorithm videos and this works the best for all my cases.
I think we should pick the pivot and start comparing , value at i and pivot value not pivot is shifted at last.index and keep swaping based on element values Pseudo Code : QUICKSORT(A) 1: if A is empty then 2: return A 3: last← (length(A) − 1).index 4: pivot ← A[last] // Take last element as pivot 5: less ← {A[i] | A[i] ≤ pivot, i != last} 6: more ← {A[i] | A[i] > pivot, i != last} 7: return (QUICKSORT(less), pivot, QUICKSORT(more))
4:03 In the Partition func, `low` never gets modified so the `for` loop would deadlock. In the Python example linked from this video it uses `range` that increments so the loop won't deadlock. Sorry if this is duplicated info.
I feel like the pseudo code would reflect the presentation a lot more if we let pivot be A[high] with rightwall=high-1. Then the conditional statement to initiate swap would be if(A[i]>pivot), and of course having rightwall=rightwall+1
Take a pivot as the biggest number, the code will recurse an infinite number of times. And you can't simply swap A[i] and A[leftwall] in for loop based on A[i] < pivot. We also need to consider if A[high] < pivot before swapping.
According to the pseudo code, the video should pick 2 as pivot and compare the rest number with 2 and when encounter 1 then swap 1 with 2, and then swap 0 with 6 and swap then lefwall=3 so swap 5 with the pivot 2. That finishes the first partition.
Why the pseudocode doesn't intuitively reflect the walk through? (Quote from Wikipedia) "The pivot selection and partitioning steps can be done in several different ways; the choice of specific implementation schemes greatly affects the algorithm's performance." There are two partition schemes: 1. Lomuto partition scheme, which is the pseudocode provided in the video. 2. Hoare partition scheme, which is the walkthrough in the video. Comparison (Quote from Wikipedia) 1. "As the Lomuto partition scheme is more compact and easy to understand, it is frequently used in introductory material, although it is less efficient than Hoare's original scheme." 2. "Hoare's scheme is more efficient than Lomuto's partition scheme because it does three times fewer swaps on average, and it creates efficient partitions even when all values are equal." To understand the Lomuto partition scheme more, I recommend a TH-cam video called "Quicksort: Partitioning an array" by KC Ang.
![【중1_BLACK】 20241123 토 [중1-2] 2학기 기말고사 대비 2차 꼭풀 모의고사 해설](http://i.ytimg.com/vi/USjJhfxN1Nw/mqdefault.jpg)
This is great video! but, I feel the algo provided in the end is not the same as the way he was explaining.. I went ahead and wrote my code for it same way he explained:
```
class Solution:
def sortArray(self, nums: List[int]) -> List[int]:
def quicksort(nums, lo, hi):
if lo < hi:
partition_resting_point = partition(nums, lo, hi)
quicksort(nums, lo, partition_resting_point - 1)
quicksort(nums, partition_resting_point + 1, hi)
def partition(nums, lo, hi):
pivotIdx = random.randint(lo, hi)
nums[pivotIdx], nums[hi] = nums[hi], nums[pivotIdx]
pivot = nums[hi]
l_idx = lo
r_idx = hi-1
while l_idx
Yeah, in the early days I didn't spend enough time on pseudocode. Trying to fix that now by building out this repo: github.com/msambol/youtube/blob/master/sort/quick_sort.py. Thanks for the feedback!
@@MichaelSambol I got really confused when the pseudocode didn't match the explanation. You should correct that (in the video) ASAP.
@@westsideslasha I'm sorry about that! TH-cam won't let me change the video now unfortunately, but I pinned this comment.
I am encountering an infinite loop if I change the while condition to be i < j instead of
i am glad that i looked at the comment section after having a hard time connecting the pesudo code to the video content.
With every new quick sort video, I watch, I get more recursively confused.
same lol all the quicksort videos use the same words to explain it
hey man, after pulling my hair out for 2 days I finally got it, sadly I had to pay for it.
@@अनिष्टदेव-श7य what did u pay for?
@@HACKINGMADEFUN a Udemy course
@@अनिष्टदेव-श7य cool
Guy: "I think you understand the concept"
Me: No I don't
it gets halved and is recursively applied to both halves in each step
@@Evokans um what?
@@sleevman It gets repeatedly done on each new half, as after each half the pivot is in the right place, so a new pivot is used.
@@faith2756 sorry wat?
@@sleevman Which part exactly do you not understand?
I feel so dumb when i don't understand this, but then i just scroll the comment section and realise that im not alone lol
understanding the meaning of pivot is the KEY.
yeah, theitemfromleft, or right wasn't even properly discussed, left of what or right of what exactly?
lol
he is missing lot of steps , this video is a crime
that's because it's explained horribly in this video
i should be working at mcdonalds
You really should. *SAD!*
@@SkillUpMobileGaming You too
wait what. why
lol 😂😂😂
that's what I was thinking. you're a genius pal
So we let magic handle the rest.
HAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHA
After you swap itemFromLeft and the pivot at the end, itemFromLeft is now at the end of the array. So, use that as the *new* pivot.
Repeat that until its sorted.
@@airex12 so 8 is the new pivot? How can I go through if there is no number in the array greater than 8?
@@kennethquilantang8080 after 7 is put in its correct position, remember that all numbers to the right of 7 are greater than 7. In this case, there is only one number - 8. A partition with just one number is already sorted, so you can ignore it and move on to sort [6,5] to the left of 7.
For sorting [6,5] choose 5 as the pivot. itemFromLeft is therefore 6, and itemFromRight has no value because no number in the array smaller than 5. Therefore, we can stop and swap itemFromLeft and the pivot to leave [5,6].
Yes, the video is unclear because it does not explain these cases. The point is that each time you put the pivot into it's correct position, you have "split" the array into two parts - one part has all numbers bigger than the pivot and the other part has all numbers smaller than the pivot. Parts with *just one* element are already sorted. If a part is already sorted, no itemFromLeft can be found. If a part is unsorted, you are guaranteed to find an itemFromLeft, and if the index of itemFromRight < the index of itemFromLeft *OR* itemFromRight does not exist then you can swap itemFromLeft and the pivot to put the pivot into its correct position in the whole array.
@@airex12 I get your point bro thanks but what would be the next step. Will I need to pick another pivot? How can I sort the rest?
To ones without enough background knowledge, this video omits details of execution of each step. But to ones with, this is concise and covers sufficient key points of quick sort. Thanks a lot for your video sharing.
Thats the fanciest wording I've heard, i would use: "You get it or you dont"
Try to sort a few short sequences yourself according to the steps in the video. You may get the "background knowledge".
*screams in Ross voice* PIVOT! PIVOT! PIVOT!
haha, I can't help imaging Ross's face, hahaha
Me in future, oh Ross's couch sort?
screams in Chandler voice SHUT UP! SHUT UP! SHUT UP!
Oh my GOOOOD :-))))))))))))) So truuuuueeeeeee
This is exactly what came into my mind learning about this :))
How to get Confused in 4 minutes
then again, this was the best video about it so far
I want more videos like this where they explain stuff in less than 10 minutes
Bet ? th-cam.com/video/Zh37XyQLHkw/w-d-xo.html
there's a video by abdul. i think it is best
am still confused
N Betancourt cuz the way he explains it IS confusing
I’ve watched this a couple of times, thought I understood went to the exam and screwed up
Now that I’ve watched other videos I understand that the way he explains it is confusing
N Betancourt He made it more confusing, for sure.
He didn't explain what quick sort does in general, what it can be applied to, and left some holes in the explanation that someone with no experience would struggle to grasp. Which is a shame.
Hope this helps :th-cam.com/video/Zh37XyQLHkw/w-d-xo.html
i hope you got it cute bird from nichijou
you should put the code next to all of the visual aids and highlight each line as its being done in the visual. thanks for the help with sorting!
The psudocode is not intuitively reflecting the walkthrough
I've been looking at it for a few minutes now, and I can believe that this pseudocode is accurate, but I'd have to check the details of what the partition function is doing to be sure, but it seems legit. Assuming your language of choice will permit a self-referential function like that.
@@diabl2master The recursion is fine... he's talking about how `partition` is putting the pivot on the left wall instead of the right. In the video the pivot is on the right side.
@@jscholex That would be a failure of technically reflecting, not intuitively reflecting, the walkthrough. I'm not sure OP was referring to that, but who knows.
@@diabl2master Yeah who knows... but I think we can all agree the pseudocode isn't great hah
the pseudocode shows the Lomuto version but the visualisation is for the Hoare version, which is better. See Wikipedia for both.
If anyone is confused at the 1:10, basically he doesn't go through the loop.
Instead he jumps to when item from left is higher or item from right is smaller etc. There is a left and right pointer that checks for the condition and then left++ or right-- if its not correct.
itemsfromRight goes from 1 cuz its smaller, and then the right-- checks 7, not smaller, right--, checks 8 not smaller, right-- and then it checks the 0 and see that its smaller.
Thanks for the explanation!
what the hell are you talking about this is a church sir
@@jamboy1843 I don't even remember making this comment.
i put this at 1.5x and now i learnt quick sort 2.6667 minutes
Imagine newcomers watching this explanation for the first time.
Thank you. I feel the same about my actual online course I'm studying. And I'm a newcomer. I feel better.
horrible
I study computer science, and once, I had an exam with a few sort algorithms in it. I didn't really study but about twenty minutes before the exam I watched your 2-4 minute videos on these sort algorithms and I passed the exam. Thank you for helping me.
thats gonna b me td lmao
@@fireboywatergirl1625 i am sure you are at the right place.
Michael Sambol, You're amazing! Let's be friends and have fun together!
LOL this is one of the best and easiest video out there on quick sort. All of you disliking it shouldn't do programming.
Yess I finally understood it, having a clear mind the morning before the exam helped
better and much easier algo than any standard quicksort algo available in the books
This is great. The simple explanation and the especially simple pseudocode towards the end makes it easy to understand the core concept of the algorithm.
people are complaining but this is gonna come in clutch for my wirtten exam tmr.
explained it much fckin better in 4 minutes with 1.5x watchspeed than my teacher in a 90 minutes class, thank you sm
Very very good video, thank you! I really love how you never stutter over your words, and never say uhm or uhhhh. That makes this very easy to watch.
Thank you so much, i have a pc science test today, and i didn'T understand since i can't speak german that well and i am still learning it, this guy explained it all
This is the most confusing and incoherent visualization of quicksort I've ever seen
Well said 👍
Makes perfect sense to me
Christian May That’s so great! 🙌👏
I thought the visualisation was fine. I feel that I understand it now.
This is the fist visualisation of quick-sort I've ever seen, so I know it doesn't mean much, but I agree.
This is the first video that made me really understand how to impl quicksort, and it's very short.
when i search for something on youtube and see one of your videos in the results i genuenly get excited
thank u so much, i have an exam tommorow and was stressing bc i couldnt figure out how quick sort work with my teacher's explanation and this just simplified it easily. tysm ;-;
I think I'm here for the fourth time now.
I watched several videos, including my school books, and I had no idea what they were saying with left to right and could not get the answers in the correct order because of that. I was able to understand after watching your video and it allowed me to get past my assignment. Thank you.
Thanks for clear explanation. Correct Position for Pivot, let recursive do remains. Good job man.
Great series man! This week is my Algorithms II exam and these helped me. Keep it up :)
Nice! Glad to see magic still exists!
Thank u very much Sir, I got it completely. Actually I'd missed my college online lecture b/c of sleeping... U saved me just night before exam, as urs is the shortest video on YT.
Your short videos helped me a looot. Thank you so much!
The video hold the key of quicksort, most clear to me!
There was quiet a bit of sigma in this video wouldn't you say my fellow skibidis?
Wow... You just found a place in my mind where you stored quick sort so deeply.🙋💖😂
The visualization is perfect!
These 4 minute videos are great for cramming!
Psuedo code does not match demonstrated algorithm.
Very good video, I learned quick sort easily thanks to this. Although, I did have to rewatch the "median-of-three" explanation.
all your videos are short and very useful.
Thank you for the video. I am grateful for your time and contribution. Kind regards, Akira.
That is the exact! same Quick Sort Algorithm we have been thought. Really good! Thanks
This will be useful for tomorrow's exam.
The video explains the concept of quicksort, a recursive algorithm used for sorting arrays. It emphasizes the importance of choosing a pivot and demonstrates the process of partitioning the array. The video also mentions the pseudocode for quicksort and discusses its time complexity.
Understanding Quicksort Algorithm
00:00 Quicksort is a recursive algorithm that uses a pivot to sort an array.
00:13 The pivot is placed in its correct position, with smaller items to the left and larger items to the right.
03:24 Choosing the pivot properly is crucial for the performance of the algorithm.
FINALY SOMEONE WITH CLEAR INSTRUCTIONS
Thanks Brother, You save my 10 min exam fast revision time
i cannot even describe how much i hate learning these, thanks for the video it helps a lot
it's 8:48 AM, i have an exam at 15:30 PM and ur saving me here
Perfect explanation of quick sort!!
These are some clean tutorials. Thank you for making this!
Helped me. Great vid. Fan of your since now. Cheers.
Hvala ti brate pomogao si mi puno u životu
this made it a lot more logical for me, thank you.
Hey, Thanks for the explanasion, It was a clear and concise video, however the pseudocode is somewhat wrong I believe in 3 things:
In Partition, the order of operations is not correct: increment leftwall first, then swap.
The final swap in Partition is not correctly swapping the pivot's original position with A[leftwall].
The recursive calls in Quicksort should be updated to exclude the pivot_location from the ranges, properly dividing the array into segments that exclude the sorted pivot.
here is the corrected version:
Quicksort(A as array, low as int, high as int)
if (low < high)
pivot_location = Partition(A, low, high)
Quicksort(A, low, pivot_location - 1)
Quicksort(A, pivot_location + 1, high)
Partition(A as array, low as int, high as int)
pivot = A[low]
leftwall = low
for i = low + 1 to high
if (A[i] < pivot) then
leftwall = leftwall + 1
swap(A[i], A[leftwall])
swap(A[low], A[leftwall])
return(leftwall)
Thanks again!
QuickSort has always been a bit of a mystery to me, but somehow this video instantly made it click. Thank you so much!
currently studying for my Algorithms and Data Structure exam, your video is very helpful :)
thanks
The pseudocode is hard to read, but the variable name "leftwall" is really good, this gives me a vivid concept of how the leftmost larger item was swapped and the "wall" moved.
pseudocode is actually wrong as well !
@@hiteshsahu_ Exactly, not only 1 pointer moves & stopping when this 1 pointer reaches end of the array, but also only picking leftmost value as pivot
@@hiteshsahu_ Exactly , i have wasted so much time over it
@@blurryhorizon I suppose that in the Partition function, the "pivot = A[low]" should actually be "pivot = A[high]"? Very confusing so I wrote it down and found out that the pseudocode doesn't work properly. // Oh just realised that although pivot = A[low] might works as well but the pseudocode is totally wrong for Partition function jeez..
@@scarlettwang2146 I think it should be as it is. Something else is wrong.
"let's let recursion handle the rest" > "here's the rest of the owl"
My prof taught me this is in like 1 hour(nothing reached to my braincells)but this 4 minutes taught me well ☝️
I wish the video was longer… You explained quite well, but I would love to learn more about the details that you didn’t get a chance to cover.
That without voice over made the video from great to perfect
God bless you man this is by far the most straightforward and comprehensible explanation of quicksort, really got me out of a pickle with this one.
God bless, Mitch
This was exactly the kind of video I was looking for!! Short and concise, but no loss of information. Thank you.
I really like this explanation. This moves the pivot out of the way and swaps it back with the itemFromLeft pointer. That's so much easier than some other videos I've seen where the pivot is in the middle of the action and we're confused with >= or
yes! It is cool!
watching this video from NEPAL.
Great sir. THANK YOU.
This algo is akin to a toddler randomly sorting numbers around until they're in order
amazing, ive got an exam tmrw... this lesson is much appriciated as my professor is not very good at explaining these basics
The comments on this video do not reflect the like/dislike ratio.
I guess, In the quicksort explanation he moves the pivot to the RIGHT END of the array.
In the pseudocode, he moves the pivot to the LEFT end of the array. And after the swapping is done, he then brings the pivot to the original position from the LEFTEND.
I've seen too many quicksort algorithm videos and this works the best for all my cases.
I think we should pick the pivot and start comparing , value at i and pivot value not pivot is shifted at last.index and keep swaping based on element values
Pseudo Code :
QUICKSORT(A)
1: if A is empty then
2: return A
3: last← (length(A) − 1).index
4: pivot ← A[last] // Take last element as pivot
5: less ← {A[i] | A[i] ≤ pivot, i != last}
6: more ← {A[i] | A[i] > pivot, i != last}
7: return (QUICKSORT(less), pivot, QUICKSORT(more))
this is the best channel ever
thank you! please help spread the word :)
here for the comments
VERY UNIQUE TASTE 8|
This is exactly what I was looking for in a video
I'm seeing myself working customer service for the rest of my life
Thanks for the concise and succinct tutorial.
Him: “quick sort = pivot”
Me: “WHILE HE HID IN RADIO WE PIVOTED TO VIDEO 🗣️💥”
Oh damn. When it's explained like this, it really makes sense. I could totally code this lmao
Code is not right.
"leftwall = leftwall + 1;" needs to happen right before "swap(array[i], array[leftwall]);" not after it.
Agree!
I actually understand a little bit now, thanks!
I can now finally sort my life out
Doesn't this guy know Left and Right or what
Lol
lol
@@zolongOne lol again
4:03 In the Partition func, `low` never gets modified so the `for` loop would deadlock. In the Python example linked from this video it uses `range` that increments so the loop won't deadlock. Sorry if this is duplicated info.
It was quick and I understood everything. Thanks a lot
Needs a bit more of an indepth explaination :/
Honestly the phrasing is confusing. This easier if you ignore half of it and just watch the numbers.
Edit: ok, maybe bad advice..
@@thehammurabichode7994 indeed bad advice
Your videos are busteling always, keep cooking!
Now this one better!
I feel like the pseudo code would reflect the presentation a lot more if we let pivot be A[high] with rightwall=high-1. Then the conditional statement to initiate swap would be if(A[i]>pivot), and of course having rightwall=rightwall+1
my professor is horrible at explaining this so I had to find a youtube video about quicksort and teach myself
Thanks. Pretty simple explanation.
0:10 who else thought of Ross screaming Pivot from that Friends Episode
what if i encountered an element equal to the pivot
I am glad I read the comment to know that I am not the only one!
Take a pivot as the biggest number, the code will recurse an infinite number of times.
And you can't simply swap A[i] and A[leftwall] in for loop based on A[i] < pivot. We also need to consider if A[high] < pivot before swapping.
but how could A[high] be less than pivot if the high is supposed to be a value greater than pivot? and why not always pick a pivot from the middle?
According to the pseudo code, the video should pick 2 as pivot and compare the rest number with 2 and when encounter 1 then swap 1 with 2, and then swap 0 with 6 and swap then lefwall=3 so swap 5 with the pivot 2. That finishes the first partition.
thank you so insightful :)
me too
yo me too
Why the pseudocode doesn't intuitively reflect the walk through?
(Quote from Wikipedia) "The pivot selection and partitioning steps can be done in several different ways; the choice of specific implementation schemes greatly affects the algorithm's performance."
There are two partition schemes:
1. Lomuto partition scheme, which is the pseudocode provided in the video.
2. Hoare partition scheme, which is the walkthrough in the video.
Comparison (Quote from Wikipedia)
1. "As the Lomuto partition scheme is more compact and easy to understand, it is frequently used in introductory material, although it is less efficient than Hoare's original scheme."
2. "Hoare's scheme is more efficient than Lomuto's partition scheme because it does three times fewer swaps on average, and it creates efficient partitions even when all values are equal."
To understand the Lomuto partition scheme more, I recommend a TH-cam video called "Quicksort: Partitioning an array" by KC Ang.
thank you a lot!