@Sahil-sm5re
This is the best JAVA course out here! watching this in 2025 this is still better than many paid courses. Anyone watching this in please believe when he is saying that this course is better than many paid courses out there!
@Tomharry910
I remember plucking out my hair on recursion and sorting algos before stumbling on your videos. You explain it very well and its very intellectually satisfying to watch your videos as well.
@nishantsingh8477
There's this merge sort and quick sort, people say its hard to understand this and so I left them and proceeded further in my DS journey. But I was damn sure you will make it easy and so listened to you and Now I know this . Thankyou KK Bhaiya 🤩
@hc-dc7043
One of the best explanations I've seen for Quick Sort. The way he broke the concept down to its nuts and bolts is really amazing.
@AshishKumar-ys7rj
best lecture on yt for quick sort because it is the most efficient i have seen, but first watch the quick sort algorithm by striver, he will clear all the doubts if you have got any by watching this lecture , since i had lot of doubts . Once you understand the algorithm u can follow the code here . The concept will be crystal clear then .
@sagarmore9425
I have tried to understand merge sort and quick sort literally a thousand times. In college, classes, some time by me. I was not able to visualize how it is actually working with recursion, although I knew the code. But the way, you are simplifying the things and the way you have had the first recursion video done is just awesome. That first recursion video is quite important and on top of this you explained this sorting so well, kudos man!
@mohammedsaad0761
The video explains the quicksort algorithm in detail, covering its theory, complexity, and coding implementation, while comparing it with other sorting algorithms like merge sort and discussing internal sorting functions in Java and Python.
Detailed Summary for [Quick Sort Using Recursion (Theory + Complexity + Code)](https://www.youtube.com/watch?v=Z8svOqamag8) by [Monica](https://monica.im)
[00:04](https://www.youtube.com/watch?v=Z8svOqamag8&t=4) Understanding the importance of Quicksort in sorting algorithms
- Introduction to Quicksort and its significance in interviews}
- Covering the complexity, time, space, code, advantages, and disadvantages of Quicksort}
- Exploring internal sorting algorithms and hybrid sorting techniques}
[05:15](https://www.youtube.com/watch?v=Z8svOqamag8&t=315.199) Explanation of quick sort using recursion
- Explanation of partitioning elements based on a pivot}
- Role of recursion in sorting process}
- Unique aspect of pivot placement in quick sort}
- Recursion's role in sorting the left and right partitions}
- Selection of a new pivot element for further partitioning}
[10:33](https://www.youtube.com/watch?v=Z8svOqamag8&t=633.44) Explanation of how to perform quick sort using recursion
- Explanation of selecting the pivot element}
- Identifying violations in the elements compared to the pivot}
- Fixing violations by swapping elements}
- Comparison and handling of elements in relation to the pivot}
[15:49](https://www.youtube.com/watch?v=Z8svOqamag8&t=949.04) Explanation of the quick sort algorithm using recursion
- Explanation of choosing the pivot and dividing the array}
- Demonstration of the pivot at the correct position}
- Discussion on picking the pivot element}
- Introduction to complexity analysis}
- Partitioning the elements based on the chosen pivot}
[21:07](https://www.youtube.com/watch?v=Z8svOqamag8&t=1267.12) Understanding the time complexity of Quick Sort using recursion
- Explaining the time taken to put the pivot at the correct position}
- Discussing the recurrence relation of Quick Sort}
- Analyzing the worst-case scenario in Quick Sort}
- Illustrating the impact of choosing the smallest or largest pivot element}
- Highlighting the consequences of the worst-case scenario in Quick Sort}
[26:22](https://www.youtube.com/watch?v=Z8svOqamag8&t=1582.48) Explanation of time complexity and space complexity in Quick Sort
- Detailed explanation of time complexity using Akra-Bazzi formula}
- Importance of understanding space and time complexity in algorithms}
- Best case and worst case complexity of Quick Sort}
- Stability of algorithms and the concept of stable sorting}
- Previous video covering sorting algorithms and stability in detail}
[31:40](https://www.youtube.com/watch?v=Z8svOqamag8&t=1900.48) Introduction to Quick Sort Using Recursion
- Starting the coding part for quick sort}
- Explaining the concept of low and high indices}
- Using pointers to manipulate the object in the array}
[36:57](https://www.youtube.com/watch?v=Z8svOqamag8&t=2217.68) Explanation of quick sort using recursion and its implementation
- Explanation of the recursion process in quick sort}
- Dividing the array into two halves for sorting}
- Initialization of low and high variables for sorting}
- Discussion on different approaches to quick sort}
- Recommendation to try other sorting methods before asking for help}
@tejasvijain1077
Before watching this vid, i was on gfg and javapoint understanding what quick sort was and my god, kunal has explined it so well and he hasnt copied what they did and I was blown by how easy he has made this!! Kudos bro,
@gitansh194
00:05 Quicksort is a crucial sorting algorithm frequently asked in interviews. 02:11 Quick sort uses pivot to divide elements into smaller and larger groups. 06:22 Quick Sort uses recursion to position the pivot element correctly after each pass. 08:20 Quick sort uses recursion to sort arrays efficiently 12:24 Understanding how to identify violations while sorting using Quick Sort. 14:35 Moving the pivot to the correct position using recursion 18:43 Picking the pivot element in quick sort 20:34 Understanding time complexity and recurrence relation in Quick Sort. 24:23 Quick sort's time complexity is O(n^2), covered in detail 26:22 Recurrence relation of merge sort explained with time complexity formulas. 29:36 Hybrid sorting algorithms combine merge sort and insertion sort for efficiency. 31:26 Exploring new approaches to solve problems is recommended. 34:59 Moving elements according to pivot and violating conditions 36:36 Explanation of the swapping process and recursion call in Quick Sort using recursion. 40:23 Quick sort is a hybrid sorting algorithm 41:58 Quick Sort using recursion is a common sorting algorithm.
@SochtaHoonMain
Kunal Kushwaha : "Your start is low , Your End is going to be high" :)
@anshulgoel1940
An alternative approach is to swap the pivot with the last index before we start in each recursive call and then start comparing left and right. Once index cross over, we swap pivot with left pointer. Works out much cleaner at code level.
@karthikpm9669
this is good...i mean its good that you didnt advertise your videos in a humble way , because people wont know how good your videos are. PS i didnt realise how fast time went , the way you taught was very smooth and seemed like a story to me.
@mk_ahmar
Hey Kunal, your lectures are valuably explained, and covers everything one should know sooner or later. For example after watching this QuickSort lecture, all I've to do is practice some question, I don't need to watch any more concept of this anywhere, and this is amazing. You and your video lectures are underrated, if this quality of lectures are provided by any EdTech they would have charged that course extravagant. Hope I'll be able to get ₹7Lakh/month 😂(Joking).
@shantahiremath7313
Thank you Kunal Sir. You are always the best teacher. I never learned this sort by fearing the complexity. But now you made it a cakewalk. Always grateful.
@Sillysmiles76
Such a blessing to learn DSA with your videos.😇 Please complete the series.🙂
@vinaykrishna747
Please Use Black Background for writing on the screen It doesn't affect eyes much 😊😊 Consider this Man
@abhijitmanna4524
My java code is not compiling at 38:21 any solution ?
@Mohit_Gupta24
As always brilliant explanation. I used to be scared of quick sort in my college days, but this video makes it seem really easy. Moreover, I was able to relate Step: placing pivot at the correct index with Binary Search step. In binary search, we search for a target element, assuming the array is sorted, and use the start and end indexes as pointers to the virtual array. Here we have to just place the pivot at the correct index, so instead of searching the target, we already have the target(i.e. pivot), we have to put at correct index and in this process we are ensuring elements less than pivot are on LHS, and elements greater than pivot are RHS.
@rohitchilhorkar8114
I can't even express how much value it is providing us...hats off kunal bhai!
@KunalKushwaha