Quicksort is a divide-and-conquer sorting algorithm that works as follows:
1. Pick a pivot element and partition the array around it so that all elements less than the pivot come before elements greater than the pivot.
2. Recursively apply quicksort to the subarrays on each side of the pivot.
The average time complexity of quicksort is O(n log n) because on average the partitioning divides the array into equal halves at each step. However, the worst case is O(n^2) if the array is already sorted. Choosing the median element as the pivot helps avoid this worst case.
Sorting plays a very important role in data structure.
Different type of sorting is given that is most popular and mostly used. It is described in very easy and brief way.
In this playlist
https://youtube.com/playlist?list=PLT...
I'll illustrate algorithms and data structures course, and implement the data structures using java programming language.
the playlist language is arabic.
The Topics:
--------------------
1- Arrays
2- Linear and Binary search
3- Linked List
4- Recursion
5- Algorithm analysis
6- Stack
7- Queue
8- Binary search tree
9- Selection sort
10- Insertion sort
11- Bubble sort
12- merge sort
13- Quick sort
14- Graphs
15- Hash table
16- Binary Heaps
Reference : Object-Oriented Data Structures Using Java - Third Edition by NELL DALE, DANEIEL T.JOYCE and CHIP WEIMS
Slides is owned by College of Computing & Information Technology
King Abdulaziz University, So thanks alot for these great materials
One of the most important tasks when analyzing a collection of numbers is to find the ith smallest element. Examples of these elements are
• The minimum
• The maximum
• The Median for n odd,
Then, it is necessary to find fast solutions to find this statistics.
ARENA - Young adults in the workplace (Knight Moves).pdfKnight Moves
Presentations of Bavo Raeymaekers (Project lead youth unemployment at the City of Antwerp), Suzan Martens (Service designer at Knight Moves) and Adriaan De Keersmaeker (Community manager at Talk to C)
during the 'Arena • Young adults in the workplace' conference hosted by Knight Moves.
Sorting plays a very important role in data structure.
Different type of sorting is given that is most popular and mostly used. It is described in very easy and brief way.
In this playlist
https://youtube.com/playlist?list=PLT...
I'll illustrate algorithms and data structures course, and implement the data structures using java programming language.
the playlist language is arabic.
The Topics:
--------------------
1- Arrays
2- Linear and Binary search
3- Linked List
4- Recursion
5- Algorithm analysis
6- Stack
7- Queue
8- Binary search tree
9- Selection sort
10- Insertion sort
11- Bubble sort
12- merge sort
13- Quick sort
14- Graphs
15- Hash table
16- Binary Heaps
Reference : Object-Oriented Data Structures Using Java - Third Edition by NELL DALE, DANEIEL T.JOYCE and CHIP WEIMS
Slides is owned by College of Computing & Information Technology
King Abdulaziz University, So thanks alot for these great materials
One of the most important tasks when analyzing a collection of numbers is to find the ith smallest element. Examples of these elements are
• The minimum
• The maximum
• The Median for n odd,
Then, it is necessary to find fast solutions to find this statistics.
ARENA - Young adults in the workplace (Knight Moves).pdfKnight Moves
Presentations of Bavo Raeymaekers (Project lead youth unemployment at the City of Antwerp), Suzan Martens (Service designer at Knight Moves) and Adriaan De Keersmaeker (Community manager at Talk to C)
during the 'Arena • Young adults in the workplace' conference hosted by Knight Moves.
Storytelling For The Web: Integrate Storytelling in your Design ProcessChiara Aliotta
In this slides I explain how I have used storytelling techniques to elevate websites and brands and create memorable user experiences. You can discover practical tips as I showcase the elements of good storytelling and its applied to some examples of diverse brands/projects..
White wonder, Work developed by Eva TschoppMansi Shah
White Wonder by Eva Tschopp
A tale about our culture around the use of fertilizers and pesticides visiting small farms around Ahmedabad in Matar and Shilaj.
Between Filth and Fortune- Urban Cattle Foraging Realities by Devi S Nair, An...Mansi Shah
This study examines cattle rearing in urban and rural settings, focusing on milk production and consumption. By exploring a case in Ahmedabad, it highlights the challenges and processes in dairy farming across different environments, emphasising the need for sustainable practices and the essential role of milk in daily consumption.
Maximize Your Content with Beautiful Assets : Content & Asset for Landing Page pmgdscunsri
Figma is a cloud-based design tool widely used by designers for prototyping, UI/UX design, and real-time collaboration. With features such as precision pen tools, grid system, and reusable components, Figma makes it easy for teams to work together on design projects. Its flexibility and accessibility make Figma a top choice in the digital age.
Can AI do good? at 'offtheCanvas' India HCI preludeAlan Dix
Invited talk at 'offtheCanvas' IndiaHCI prelude, 29th June 2024.
https://www.alandix.com/academic/talks/offtheCanvas-IndiaHCI2024/
The world is being changed fundamentally by AI and we are constantly faced with newspaper headlines about its harmful effects. However, there is also the potential to both ameliorate theses harms and use the new abilities of AI to transform society for the good. Can you make the difference?
Explore the essential graphic design tools and software that can elevate your creative projects. Discover industry favorites and innovative solutions for stunning design results.
1. AD3251 - DATA STRUCTURES DESIGN
KGiSL Institute of Technology
2. 2
Quick Sort
Fastest known sorting algorithm in practice
Average case: O(N log N)
Worst case: O(N2)
But the worst case can be made exponentially unlikely.
Another divide-and-conquer recursive algorithm, like merge sort.
3. 3
Quick Sort: Main Idea
1. If the number of elements in S is 0 or 1, then return (base case).
2. Pick any element v in S (called the pivot).
3. Partition the elements in S except v into two disjoint groups:
1. S1 = {x S – {v} | x v}
2. S2 = {x S – {v} | x v}
4. Return {QuickSort(S1) + v + QuickSort(S2)}
6. 6
Issues To Consider
How to pick the pivot?
Many methods (discussed later)
How to partition?
Several methods exist.
The one we consider is known to give good results and to be easy and
efficient.
We discuss the partition strategy first.
7. 7
Partitioning Strategy
For now, assume that pivot = A[(left+right)/2].
We want to partition array A[left .. right].
First, get the pivot element out of the way by
swapping it with the last element (swap pivot and
A[right]).
Let i start at the first element and j start at the next-to-
last element (i = left, j = right – 1)
pivot i j
5 7 4 6 3 12 19 5 7 4 6
3 12
19
swap
8. 8
Partitioning Strategy
Want to have
A[k] pivot, for k < i
A[k] pivot, for k > j
When i < j
Move i right, skipping over elements smaller than the pivot
Move j left, skipping over elements greater than the pivot
When both i and j have stopped
A[i] pivot
A[j] pivot A[i] and A[j] should now be swapped
i j
5 7 4 6
3 12
19
i j
5 7 4 6
3 12
19
i j
pivot pivot
9. 9
Partitioning Strategy (2)
When i and j have stopped and i is to the left of j (thus
legal)
Swap A[i] and A[j]
The large element is pushed to the right and the small element
is pushed to the left
After swapping
A[i] pivot
A[j] pivot
Repeat the process until i and j cross
swap
i j
5 7 4 6
3 12
19
i j
5 3 4 6
7 12
19
10. 10
Partitioning Strategy (3)
When i and j have crossed
swap A[i] and pivot
Result:
A[k] pivot, for k < i
A[k] pivot, for k > i
i j
5 3 4 6
7 12
19
i
j
5 3 4 6
7 12
19
i
j
5 3 4 6 7 12 19
swap A[i] and pivot
Break!
11. Picking the Pivot
There are several ways to pick a pivot.
Objective: Choose a pivot so that we will get 2 partitions
of (almost) equal size.
12. 12
Picking the Pivot (2)
Use the first element as pivot
if the input is random, ok.
if the input is presorted (or in reverse order)
all the elements go into S2 (or S1).
this happens consistently throughout the recursive
calls.
results in O(N2) behavior (we analyze this case later).
Choose the pivot randomly
generally safe,
but random number generation can be expensive and
does not reduce the running time of the algorithm.
13. 13
Picking the Pivot (3)
Use the median of the array (ideal pivot)
The N/2 th largest element
Partitioning always cuts the array into roughly half
An optimal quick sort (O(N log N))
However, hard to find the exact median
Median-of-three partitioning
eliminates the bad case for sorted input.
reduces the number of comparisons by 14%.
14. 14
Median of Three Method
Compare just three elements: the leftmost, rightmost and center
Swap these elements if necessary so that
A[left] = Smallest
A[right] = Largest
A[center] = Median of three
Pick A[center] as the pivot.
Swap A[center] and A[right – 1] so that the pivot is at the second last
position (why?)
15. 15
Median of Three: Example
pivot
5 6 4
6
3 12 19
2 13 6
5 6 4 3 12 19
2 6 13
A[left] = 2, A[center] = 13,
A[right] = 6
Swap A[center] and A[right]
5 6 4 3 12 19
2 13
pivot
6
5 6 4 3 12
19
2 13
Choose A[center] as pivot
Swap pivot and A[right – 1]
We only need to partition A[ left + 1, …, right – 2 ]. Why?
16. Quick Sort Summary
Recursive case: QuickSort( a, left, right )
pivot = median3( a, left, right );
Partition a[left … right] into a[left … i-1], i, a[i+1 … right];
QuickSort( a, left, i-1 );
QuickSort( a, i+1, right );
Base case: when do we stop the recursion?
In theory, when left >= right.
In practice, …
17. 17
Small Arrays
For very small arrays, quick sort does not
perform as well as insertion sort
Do not use quick sort recursively for small arrays
Use a sorting algorithm that is efficient for small
arrays, such as insertion sort.
When using quick sort recursively, switch to
insertion sort when the sub-arrays have between
5 to 20 elements (10 is usually good).
saves about 15% in the running time.
avoids taking the median of three when the sub-array
has only 1 or 2 elements.
19. 19
Partitioning Part
The partitioning code we just
saw works only if pivot is picked
as median-of-three.
A[left] pivot and A[right] pivot
Need to partition only
A[left + 1, …, right – 2]
j will not run past the beginning
because A[left] pivot
i will not run past the end
because A[right-1] = pivot
20. Homework
Assume the pivot is chosen as the middle element of an array:
pivot = a[(left+right)/2].
Rewrite the partitioning code and the whole quick sort algorithm.
21. 21
Quick Sort Faster Than Merge Sort
Both quick sort and merge sort take O(N log N) in the
average case.
But quick sort is faster in the average case:
The inner loop consists of an increment/decrement (by
1, which is fast), a test and a jump.
There is no extra juggling as in merge sort.
inner loop
22. 22
Analysis
Assumptions:
A random pivot (no median-of-three partitioning)
No cutoff for small arrays ( to make it simple)
1. If the number of elements in S is 0 or 1, then return (base case).
2. Pick an element v in S (called the pivot).
3. Partition the elements in S except v into two disjoint groups:
1. S1 = {x S – {v} | x v}
2. S2 = {x S – {v} | x v}
4. Return {QuickSort(S1) + v + QuickSort(S2)}
23. 23
Analysis (2)
Running time
pivot selection: constant time, i.e. O(1)
partitioning: linear time, i.e. O(N)
running time of the two recursive calls
T(N)= T(i) + T(N – i – 1) + cN
i: number of elements in S1
c is a constant
24. 24
Worst-Case Scenario
What will be the worst case?
The pivot is the smallest element, all the time
Partition is always unbalanced
25. 25
Best-Case Scenario
What will be the best case?
Partition is perfectly balanced.
Pivot is always in the middle (median of the array).
T(N) = T(N/2) + T(N/2) + cN = 2T(N/2) + cN
This recurrence is similar to the merge sort recurrence.
The result is O(NlogN).
26. 26
Average-Case Analysis
Assume that each of the sizes for S1 is equally likely has
probability 1/N.
This assumption is valid for the pivoting and partitioning strategy
just discussed (but may not be for some others),
On average, the running time is O(N log N).
Proof: pp 272–273, Data Structures and Algorithm Analysis by M.
A. Weiss, 2nd edition