Scribd
Upload
9 views10 pages

Sorting Algo

Uploaded by

interested.towork5
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
9 views10 pages

Sorting Algo

Uploaded by

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

## Sorting Algorithms

### 1. Bubble Sort

Bubble Sort is a simple comparison-based sorting algorithm that


repeatedly steps through the list, compares adjacent elements, and swaps
them if they are in the wrong order.

- **Best Case**: \(O(n)\)


- **Average Case**: \(O(n^2)\)
- **Worst Case**: \(O(n^2)\)

void bubbleSort(std::vector<int>& arr) {


int n = arr.size();
for (int i = 0; i < n-1; i++) {
for (int j = 0; j < n-i-1; j++) {
if (arr[j] > arr[j+1]) {
std::swap(arr[j], arr[j+1]);
}
}
}
}
### 2. Selection Sort

Selection Sort divides the input list into two parts: the sublist of items
already sorted and the sublist of items remaining to be sorted. It repeatedly
selects the smallest (or largest) element from the unsorted sublist and
moves it to the sorted sublist.

- **Best Case**: \(O(n^2)\)


- **Average Case**: \(O(n^2)\)
- **Worst Case**: \(O(n^2)\)

void selectionSort(std::vector<int>& arr) {


int n = arr.size();
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;
}
}
std::swap(arr[i], arr[minIndex]);
}
}
### 3. Insertion Sort

Insertion Sort builds the final sorted array one item at a time. It is much
less efficient on large lists than more advanced algorithms such as
quicksort, heapsort, or merge sort.

- **Best Case**: \(O(n)\)


- **Average Case**: \(O(n^2)\)
- **Worst Case**: \(O(n^2)\)

void insertionSort(std::vector<int>& arr) {


int n = arr.size();
for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}
### 4. Merge Sort

Merge Sort is an efficient, stable, comparison-based, divide and conquer


sorting algorithm. Most implementations produce a stable sort, meaning
that the implementation preserves the input order of equal elements in the
sorted output.

- **Best Case**: \(O(n \log n)\)


- **Average Case**: \(O(n \log n)\)
- **Worst Case**: \(O(n \log n)\)

void merge(std::vector<int>& arr, int left, int mid, int right) {


int n1 = mid - left + 1;
int n2 = right - mid;

std::vector<int> L(n1), R(n2);

for (int i = 0; i < n1; i++) L[i] = arr[left + i];


for (int i = 0; i < n2; i++) R[i] = arr[mid + 1 + i];

int i = 0, j = 0, k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}

while (i < n1) {


arr[k] = L[i];
i++;
k++;
}

while (j < n2) {


arr[k] = R[j];
j++;
k++;
}
}

void mergeSort(std::vector<int>& arr, int left, int right) {


if (left < right) {
int mid = left + (right - left) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
### 5. Quick Sort

Quick Sort is an efficient, comparison-based, divide and conquer sorting


algorithm. It works by selecting a 'pivot' element from the array and
partitioning the other elements into two sub-arrays according to whether
they are less than or greater than the pivot.

- **Best Case**: \(O(n \log n)\)


- **Average Case**: \(O(n \log n)\)
- **Worst Case**: \(O(n^2)\)

int partition(std::vector<int>& arr, int low, int high) {


int pivot = arr[high];
int i = (low - 1);
for (int j = low; j < high; j++) {
if (arr[j] < pivot) {
i++;
std::swap(arr[i], arr[j]);
}
}
std::swap(arr[i + 1], arr[high]);
return (i + 1);
}

void quickSort(std::vector<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);
}
}

### 6. Heap Sort

Heap Sort is a comparison-based sorting algorithm that uses a binary heap


data structure. It is similar to selection sort where we first find the
maximum element and place it at the end.

- **Best Case**: \(O(n \log n)\)


- **Average Case**: \(O(n \log n)\)
- **Worst Case**: \(O(n \log n)\)

void heapify(std::vector<int>& arr, int n, int i) {


int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;

if (left < n && arr[left] > arr[largest]) {


largest = left;
}

if (right < n && arr[right] > arr[largest]) {


largest = right;
}

if (largest != i) {
std::swap(arr[i], arr[largest]);
heapify(arr, n, largest);
}
}

void heapSort(std::vector<int>& arr) {


int n = arr.size();
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(arr, n, i);
}
for (int i = n - 1; i > 0; i--) {
std::swap(arr[0], arr[i]);
heapify(arr, i, 0);
}
}
### 7. Counting Sort

Counting Sort is an integer sorting algorithm that assumes the range of the
numbers to be sorted is known. It counts the number of objects having
distinct key values, and using arithmetic to calculate the position of each
object.

- **Best Case**: \(O(n + k)\)


- **Average Case**: \(O(n + k)\)
- **Worst Case**: \(O(n + k)\)

class Solution {
public:
vector<int> sortArray(vector<int>& nums) {
int minE = *min_element(begin(nums), end(nums));
int maxE = *max_element(begin(nums), end(nums));

unordered_map<int, int> mp;

for (int& num : nums)


mp[num]++;

int i = 0;

for (int num = minE; num <= maxE; num++) {


while (mp[num] > 0) {
nums[i] = num;
i++;
mp[num]--;
}
}

return nums;
}
};

You might also like