Scribd
Upload
4 views17 pages

L27 Quick, Selection Sort

The document provides an overview of two sorting algorithms: QuickSort and Selection Sort. QuickSort uses a pivot to partition the array and recursively sort the elements, while Selection Sort repeatedly selects the smallest element from the unsorted portion and moves it to the sorted portion. Both algorithms include Java implementations for user input and sorting functionality.

Uploaded by

Tejaswa Dave
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
4 views17 pages

L27 Quick, Selection Sort

The document provides an overview of two sorting algorithms: QuickSort and Selection Sort. QuickSort uses a pivot to partition the array and recursively sort the elements, while Selection Sort repeatedly selects the smallest element from the unsorted portion and moves it to the sorted portion. Both algorithms include Java implementations for user input and sorting functionality.

Uploaded by

Tejaswa Dave
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 17

Quick, Selection

Sort
Introduction: QuickSort

QuickSort is a sorting algorithm based on the


Divide and Conquer algorithm that picks an element as a
pivot and partitions the given array around the picked
pivot by placing the pivot in its correct position in the
sorted array.
How does QuickSort work?

The key process in quickSort is a chosen to be a pivot) at its


correct position in the sorted array and put all smaller elements
to the left of the pivot,

and all greater elements to the right of the pivot.

Partition is done recursively on each side of the pivot after the


pivot is placed in its correct position and this finally sorts the
array.
Choice of Pivot:

 There are many different choices for picking pivots.


 Always pick the first element as a pivot.
 Always pick the last element as a pivot (implemented
below)
 Pick a random element as a pivot.
 Pick the middle as the pivot.
import java.util.Scanner;
class SimpleQuickSort {
static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
static int partition(int[] arr, int low, int high) {
int pivot = arr[high];
int i = (low - 1);
for (int j = low; j <= high - 1; j++) {
if (arr[j] < pivot) {
i++;
swap(arr, i, j);
}
}
swap(arr, i + 1, high);
return (i + 1);
}
static void quickSort(int[] arr, int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
public static void printArr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
public static void main(String[] args) {
Scanner scanner = new
Scanner(System.in);
System.out.print("Enter the number
of elements: ");
int N = scanner.nextInt();
int[] arr = new int[N];
System.out.println("Enter the
elements:");
for (int i = 0; i < N; i++) {
arr[i] = scanner.nextInt();
}
quickSort(arr, 0, N - 1);
System.out.println("Sorted array:");
printArr(arr);
scanner.close();
}
Selection Sort:
 Selection sort is a simple and efficient sorting algorithm that works by
repeatedly selecting the smallest (or largest) element from the unsorted
portion of the list and moving it to the sorted portion of the list.

 The algorithm repeatedly selects the smallest (or largest) element from
the unsorted portion of the list and swaps it with the first element of the
unsorted part.

 This process is repeated for the remaining unsorted portion until the
entire list is sorted.
How does Selection Sort Algorithm work?
Lets consider the following array as an example: arr[] = {64, 25, 12, 22,
11}
First pass:
 For the first position in the sorted array, the whole array is
traversed from index 0 to 4 sequentially. The first position
where 64 is stored presently, after traversing whole array it is
clear that 11 is the lowest value.
 Thus, replace 64 with 11. After one iteration 11, which happens
to be the least value in the array, tends to appear in the first
position of the sorted list.
Second Pass:
•For the second position, where 25 is present, again traverse the rest of
the array in a sequential manner.
•After traversing, we found that 12 is the second lowest value in the
array and it should appear at the second place in the array, thus swap
these values.
Third Pass:
 Now, for third place, where 25 is present again traverse the rest of
the array and find the third least value present in the array.
 While traversing, 22 came out to be the third least value and it
should appear at the third place in the array, thus swap 22 with
element present at third position.
Fourth pass:

 Similarly, for fourth position traverse the rest of the array and find
the fourth least element in the array
 As 25 is the 4th lowest value hence, it will place at the fourth
position.
Fifth Pass:
 At last the largest value present in the array automatically get placed
at the last position in the array
 The resulted array is the sorted array.
import java.util.Scanner;
public class SimpleSelectionSort {
void sort(int arr[]) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
int temp = arr[minIndex];
arr[minIndex] = arr[i];
arr[i] = temp;
}
}
void printArray(int arr[]) {
for (int i : arr) {
System.out.print(i + " ");
}
System.out.println();
}
public static void main(String args[]) {
Scanner scanner = new
Scanner(System.in);
System.out.print("Enter the number
of elements: ");
int n = scanner.nextInt();
int arr[] = new int[n];
System.out.println("Enter the
elements:");
for (int i = 0; i < n; i++) {
arr[i] = scanner.nextInt();
}
SimpleSelectionSort ob = new
SimpleSelectionSort();
ob.sort(arr);
System.out.println("Sorted array:");
ob.printArray(arr);
scanner.close();
}
}
THANK YOU

You might also like