backup/C-Plus-Plus
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/C-Plus-Plus.git synced 2026-04-24 10:33:10 +08:00
Code Issues Projects Releases Wiki Activity

formatting source-code for d7af6fdc8c

Browse Source
This commit is contained in:
github-actions
2020-05-29 23:26:30 +00:00
parent edb3d51ec2
commit 7ad1f171c1
176 changed files with 5342 additions and 4288 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
sorting/bead_sort.cpp
View File

@@ -5,11 +5,13 @@
#define BEAD(i, j) beads[i * max + j]
// function to perform the above algorithm
void beadSort(int *a, int len) {
void beadSort(int *a, int len)
{
// Find the maximum element
int max = a[0];
for (int i = 1; i < len; i++)
if (a[i] > max) max = a[i];
if (a[i] > max)
max = a[i];
// allocating memory
unsigned char *beads = new unsigned char[max * len];
@@ -19,10 +21,12 @@ void beadSort(int *a, int len) {
for (int i = 0; i < len; i++)
for (int j = 0; j < a[i]; j++) BEAD(i, j) = 1;
for (int j = 0; j < max; j++) {
for (int j = 0; j < max; j++)
{
// count how many beads are on each post
int sum = 0;
for (int i = 0; i < len; i++) {
for (int i = 0; i < len; i++)
{
sum += BEAD(i, j);
BEAD(i, j) = 0;
}
@@ -32,9 +36,11 @@ void beadSort(int *a, int len) {
}
// Put sorted values in array using beads
for (int i = 0; i < len; i++) {
for (int i = 0; i < len; i++)
{
int j;
for (j = 0; j < max && BEAD(i, j); j++) {
for (j = 0; j < max && BEAD(i, j); j++)
{
}
a[i] = j;
@@ -43,7 +49,8 @@ void beadSort(int *a, int len) {
}
// driver function to test the algorithm
int main() {
int main()
{
int a[] = {5, 3, 1, 7, 4, 1, 1, 20};
int len = sizeof(a) / sizeof(a[0]);

21
sorting/bitonic_sort.cpp
View File

@@ -9,16 +9,20 @@
/*The parameter dir indicates the sorting direction, ASCENDING
or DESCENDING; if (a[i] > a[j]) agrees with the direction,
then a[i] and a[j] are interchanged.*/
void compAndSwap(int a[], int i, int j, int dir) {
if (dir == (a[i] > a[j])) std::swap(a[i], a[j]);
void compAndSwap(int a[], int i, int j, int dir)
{
if (dir == (a[i] > a[j]))
std::swap(a[i], a[j]);
}
/*It recursively sorts a bitonic sequence in ascending order,
if dir = 1, and in descending order otherwise (means dir=0).
The sequence to be sorted starts at index position low,
the parameter cnt is the number of elements to be sorted.*/
void bitonicMerge(int a[], int low, int cnt, int dir) {
if (cnt > 1) {
void bitonicMerge(int a[], int low, int cnt, int dir)
{
if (cnt > 1)
{
int k = cnt / 2;
for (int i = low; i < low + k; i++) compAndSwap(a, i, i + k, dir);
bitonicMerge(a, low, k, dir);
@@ -29,8 +33,10 @@ void bitonicMerge(int a[], int low, int cnt, int dir) {
/* This function first produces a bitonic sequence by recursively
sorting its two halves in opposite sorting orders, and then
calls bitonicMerge to make them in the same order */
void bitonicSort(int a[], int low, int cnt, int dir) {
if (cnt > 1) {
void bitonicSort(int a[], int low, int cnt, int dir)
{
if (cnt > 1)
{
int k = cnt / 2;
// sort in ascending order since dir here is 1
@@ -50,7 +56,8 @@ void bitonicSort(int a[], int low, int cnt, int dir) {
void sort(int a[], int N, int up) { bitonicSort(a, 0, N, up); }
// Driver code
int main() {
int main()
{
int a[] = {3, 7, 4, 8, 6, 2, 1, 5};
int N = sizeof(a) / sizeof(a[0]);

25
sorting/bubble_sort.cpp
View File

@@ -40,7 +40,8 @@ optimized bubble sort algorithm. It's right down there.
#include <iostream>
#include <vector>
int main() {
int main()
{
int n;
bool swap_check = true;
std::cout << "Enter the amount of numbers to sort: ";
@@ -50,16 +51,20 @@ int main() {
int num;
// Input
for (int i = 0; i < n; i++) {
for (int i = 0; i < n; i++)
{
std::cin >> num;
numbers.push_back(num);
}
// Bubble Sorting
for (int i = 0; (i < n) && (swap_check); i++) {
for (int i = 0; (i < n) && (swap_check); i++)
{
swap_check = false;
for (int j = 0; j < n - 1 - i; j++) {
if (numbers[j] > numbers[j + 1]) {
for (int j = 0; j < n - 1 - i; j++)
{
if (numbers[j] > numbers[j + 1])
{
swap_check = true;
std::swap(numbers[j],
numbers[j + 1]); // by changing swap location.
@@ -72,10 +77,14 @@ int main() {
// Output
std::cout << "\nSorted Array : ";
for (int i = 0; i < numbers.size(); i++) {
if (i != numbers.size() - 1) {
for (int i = 0; i < numbers.size(); i++)
{
if (i != numbers.size() - 1)
{
std::cout << numbers[i] << ", ";
} else {
}
else
{
std::cout << numbers[i] << std::endl;
}
}

9
sorting/bucket_sort.cpp
View File

@@ -4,12 +4,14 @@
#include <vector>
// Function to sort arr[] of size n using bucket sort
void bucketSort(float arr[], int n) {
void bucketSort(float arr[], int n)
{
// 1) Create n empty buckets
std::vector<float> *b = new std::vector<float>[n];
// 2) Put array elements in different buckets
for (int i = 0; i < n; i++) {
for (int i = 0; i < n; i++)
{
int bi = n * arr[i]; // Index in bucket
b[bi].push_back(arr[i]);
}
@@ -25,7 +27,8 @@ void bucketSort(float arr[], int n) {
}
/* Driver program to test above funtion */
int main() {
int main()
{
float arr[] = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434};
int n = sizeof(arr) / sizeof(arr[0]);
bucketSort(arr, n);

64
sorting/cocktail_selection_sort.cpp
View File

@@ -9,27 +9,35 @@
// Iterative Version
void CocktailSelectionSort(std::vector<int> *vec, int low, int high) {
while (low <= high) {
void CocktailSelectionSort(std::vector<int> *vec, int low, int high)
{
while (low <= high)
{
int minimum = (*vec)[low];
int minimumindex = low;
int maximum = (*vec)[high];
int maximumindex = high;
for (int i = low; i <= high; i++) {
if ((*vec)[i] >= maximum) {
for (int i = low; i <= high; i++)
{
if ((*vec)[i] >= maximum)
{
maximum = (*vec)[i];
maximumindex = i;
}
if ((*vec)[i] <= minimum) {
if ((*vec)[i] <= minimum)
{
minimum = (*vec)[i];
minimumindex = i;
}
}
if (low != maximumindex || high != minimumindex) {
if (low != maximumindex || high != minimumindex)
{
std::swap((*vec)[low], (*vec)[minimumindex]);
std::swap((*vec)[high], (*vec)[maximumindex]);
} else {
}
else
{
std::swap((*vec)[low], (*vec)[high]);
}
@@ -40,28 +48,36 @@ void CocktailSelectionSort(std::vector<int> *vec, int low, int high) {
// Recursive Version
void CocktailSelectionSort_v2(std::vector<int> *vec, int low, int high) {
if (low >= high) return;
void CocktailSelectionSort_v2(std::vector<int> *vec, int low, int high)
{
if (low >= high)
return;
int minimum = (*vec)[low];
int minimumindex = low;
int maximum = (*vec)[high];
int maximumindex = high;
for (int i = low; i <= high; i++) {
if ((*vec)[i] >= maximum) {
for (int i = low; i <= high; i++)
{
if ((*vec)[i] >= maximum)
{
maximum = (*vec)[i];
maximumindex = i;
}
if ((*vec)[i] <= minimum) {
if ((*vec)[i] <= minimum)
{
minimum = (*vec)[i];
minimumindex = i;
}
}
if (low != maximumindex || high != minimumindex) {
if (low != maximumindex || high != minimumindex)
{
std::swap((*vec)[low], (*vec)[minimumindex]);
std::swap((*vec)[high], (*vec)[maximumindex]);
} else {
}
else
{
std::swap((*vec)[low], (*vec)[high]);
}
@@ -70,13 +86,15 @@ void CocktailSelectionSort_v2(std::vector<int> *vec, int low, int high) {
// main function, select any one of iterative or recursive version
int main() {
int main()
{
int n;
std::cout << "Enter number of elements\n";
std::cin >> n;
std::vector<int> v(n);
std::cout << "Enter all the elements\n";
for (int i = 0; i < n; ++i) {
for (int i = 0; i < n; ++i)
{
std::cin >> v[i];
}
@@ -84,16 +102,22 @@ int main() {
std::cout << "Enter method: \n\t0: iterative\n\t1: recursive:\t";
std::cin >> method;
if (method == 0) {
if (method == 0)
{
CocktailSelectionSort(&v, 0, n - 1);
} else if (method == 1) {
}
else if (method == 1)
{
CocktailSelectionSort_v2(&v, 0, n - 1);
} else {
}
else
{
std::cerr << "Unknown method" << std::endl;
return -1;
}
std::cout << "Sorted elements are\n";
for (int i = 0; i < n; ++i) {
for (int i = 0; i < n; ++i)
{
std::cout << v[i] << " ";
}

18
sorting/comb_sort.cpp
View File

@@ -8,13 +8,15 @@
int a[100005];
int n;
int FindNextGap(int x) {
int FindNextGap(int x)
{
x = (x * 10) / 13;
return std::max(1, x);
}
void CombSort(int a[], int l, int r) {
void CombSort(int a[], int l, int r)
{
// Init gap
int gap = n;
@@ -22,15 +24,18 @@ void CombSort(int a[], int l, int r) {
bool swapped = true;
// Keep running until gap = 1 or none elements were swapped
while (gap != 1 || swapped) {
while (gap != 1 || swapped)
{
// Find next gap
gap = FindNextGap(gap);
swapped = false;
// Compare all elements with current gap
for (int i = l; i <= r - gap; ++i) {
if (a[i] > a[i + gap]) {
for (int i = l; i <= r - gap; ++i)
{
if (a[i] > a[i + gap])
{
std::swap(a[i], a[i + gap]);
swapped = true;
}
@@ -38,7 +43,8 @@ void CombSort(int a[], int l, int r) {
}
}
int main() {
int main()
{
std::cin >> n;
for (int i = 1; i <= n; ++i) std::cin >> a[i];

71
sorting/counting_sort.cpp
View File

@@ -3,64 +3,61 @@ using namespace std;
int Max(int Arr[], int N)
{
int max = Arr[0];
for (int i = 1; i < N; i++)
if (Arr[i] > max)
max = Arr[i];
return max;
int max = Arr[0];
for (int i = 1; i < N; i++)
if (Arr[i] > max)
max = Arr[i];
return max;
}
int Min(int Arr[], int N)
{
int min = Arr[0];
for (int i = 1; i < N; i++)
if (Arr[i] < min)
min = Arr[i];
return min;
int min = Arr[0];
for (int i = 1; i < N; i++)
if (Arr[i] < min)
min = Arr[i];
return min;
}
void Print(int Arr[], int N)
{
for (int i = 0; i < N; i++)
cout << Arr[i] << ", ";
for (int i = 0; i < N; i++) cout << Arr[i] << ", ";
}
int *Counting_Sort(int Arr[], int N)
{
int max = Max(Arr, N);
int min = Min(Arr, N);
int *Sorted_Arr = new int[N];
int max = Max(Arr, N);
int min = Min(Arr, N);
int *Sorted_Arr = new int[N];
int *Count = new int[max - min + 1];
int *Count = new int[max - min + 1];
for (int i = 0; i < N; i++) Count[Arr[i] - min]++;
for (int i = 0; i < N; i++)
Count[Arr[i] - min]++;
for (int i = 1; i < (max - min + 1); i++) Count[i] += Count[i - 1];
for (int i = 1; i < (max - min + 1); i++)
Count[i] += Count[i - 1];
for (int i = N - 1; i >= 0; i--)
{
Sorted_Arr[Count[Arr[i] - min] - 1] = Arr[i];
Count[Arr[i] - min]--;
}
for (int i = N - 1; i >= 0; i--)
{
Sorted_Arr[Count[Arr[i] - min] - 1] = Arr[i];
Count[Arr[i] - min]--;
}
return Sorted_Arr;
return Sorted_Arr;
}
int main()
{
int Arr[] = {47, 65, 20, 66, 25, 53, 64, 69, 72, 22,
74, 25, 53, 15, 42, 36, 4, 69, 86, 19},
N = 20;
int *Sorted_Arr;
int Arr[] = {47, 65, 20, 66, 25, 53, 64, 69, 72, 22, 74, 25, 53, 15, 42, 36, 4, 69, 86, 19}, N = 20;
int *Sorted_Arr;
cout << "\n\tOrignal Array = ";
Print(Arr, N);
Sorted_Arr = Counting_Sort(Arr, N);
cout << "\n\t Sorted Array = ";
Print(Sorted_Arr, N);
cout << endl;
cout << "\n\tOrignal Array = ";
Print(Arr, N);
Sorted_Arr = Counting_Sort(Arr, N);
cout << "\n\t Sorted Array = ";
Print(Sorted_Arr, N);
cout << endl;
return 0;
return 0;
}

13
sorting/counting_sort_string.cpp
View File

@@ -5,18 +5,14 @@ using namespace std;
void countSort(string arr)
{
string output;
int count[256], i;
for (int i = 0; i < 256; i++)
count[i] = 0;
for (int i = 0; i < 256; i++) count[i] = 0;
for (i = 0; arr[i]; ++i)
++count[arr[i]];
for (i = 0; arr[i]; ++i) ++count[arr[i]];
for (i = 1; i <= 256; ++i)
count[i] += count[i - 1];
for (i = 1; i <= 256; ++i) count[i] += count[i - 1];
for (i = 0; arr[i]; ++i)
{
@@ -24,8 +20,7 @@ void countSort(string arr)
--count[arr[i]];
}
for (i = 0; arr[i]; ++i)
arr[i] = output[i];
for (i = 0; arr[i]; ++i) arr[i] = output[i];
cout << "Sorted character array is " << arr;
}

27
sorting/heap_sort.cpp
View File

@@ -1,7 +1,8 @@
#include <algorithm>
#include <iostream>
void heapify(int *a, int i, int n) {
void heapify(int *a, int i, int n)
{
int largest = i;
const int l = 2 * i + 1;
const int r = 2 * i + 2;
@@ -12,31 +13,38 @@ void heapify(int *a, int i, int n) {
if (r < n && a[r] > a[largest])
largest = r;
if (largest != i) {
if (largest != i)
{
std::swap(a[i], a[largest]);
heapify(a, n, largest);
}
}
void heapsort(int *a, int n) {
for (int i = n - 1; i >= 0; --i) {
void heapsort(int *a, int n)
{
for (int i = n - 1; i >= 0; --i)
{
std::swap(a[0], a[i]);
heapify(a, 0, i);
}
}
void build_maxheap(int *a, int n) {
for (int i = n / 2 - 1; i >= 0; --i) {
void build_maxheap(int *a, int n)
{
for (int i = n / 2 - 1; i >= 0; --i)
{
heapify(a, i, n);
}
}
int main() {
int main()
{
int n;
std::cout << "Enter number of elements of array\n";
std::cin >> n;
int a[20];
for (int i = 0; i < n; ++i) {
for (int i = 0; i < n; ++i)
{
std::cout << "Enter Element " << i << std::endl;
std::cin >> a[i];
}
@@ -44,7 +52,8 @@ int main() {
build_maxheap(a, n);
heapsort(a, n);
std::cout << "Sorted Output\n";
for (int i = 0; i < n; ++i) {
for (int i = 0; i < n; ++i)
{
std::cout << a[i] << std::endl;
}

15
sorting/insertion_sort.cpp
View File

@@ -2,7 +2,8 @@
#include <iostream>
int main() {
int main()
{
int n;
std::cout << "\nEnter the length of your array : ";
std::cin >> n;
@@ -10,15 +11,18 @@ int main() {
std::cout << "\nEnter any " << n << " Numbers for Unsorted Array : ";
// Input
for (int i = 0; i < n; i++) {
for (int i = 0; i < n; i++)
{
std::cin >> Array[i];
}
// Sorting
for (int i = 1; i < n; i++) {
for (int i = 1; i < n; i++)
{
int temp = Array[i];
int j = i - 1;
while (j >= 0 && temp < Array[j]) {
while (j >= 0 && temp < Array[j])
{
Array[j + 1] = Array[j];
j--;
}
@@ -27,7 +31,8 @@ int main() {
// Output
std::cout << "\nSorted Array : ";
for (int i = 0; i < n; i++) {
for (int i = 0; i < n; i++)
{
std::cout << Array[i] << "\t";
}

40
sorting/library_sort.cpp
View File

@@ -1,15 +1,15 @@
#include <algorithm>
#include <iostream>
void librarySort(int *index, int n) {
void librarySort(int *index, int n)
{
int lib_size, index_pos,
*gaps, // gaps
*library[2]; // libraries
bool target_lib, *numbered;
for (int i = 0; i < 2; i++)
library[i] = new int[n];
for (int i = 0; i < 2; i++) library[i] = new int[n];
gaps = new int[n + 1];
numbered = new bool[n + 1];
@@ -19,7 +19,8 @@ void librarySort(int *index, int n) {
target_lib = 0;
library[target_lib][0] = index[0];
while (index_pos < n) {
while (index_pos < n)
{
// binary search
int insert = std::distance(
library[target_lib],
@@ -28,19 +29,23 @@ void librarySort(int *index, int n) {
// if there is no gap to insert a new index ...
if (numbered[insert] == true) {
if (numbered[insert] == true)
{
int prov_size = 0, next_target_lib = !target_lib;
// update library and clear gaps
for (int i = 0; i <= n; i++) {
if (numbered[i] == true) {
for (int i = 0; i <= n; i++)
{
if (numbered[i] == true)
{
library[next_target_lib][prov_size] = gaps[i];
prov_size++;
numbered[i] = false;
}
if (i <= lib_size) {
if (i <= lib_size)
{
library[next_target_lib][prov_size] =
library[target_lib][i];
prov_size++;
@@ -49,7 +54,9 @@ void librarySort(int *index, int n) {
target_lib = next_target_lib;
lib_size = prov_size - 1;
} else {
}
else
{
numbered[insert] = true;
gaps[insert] = index[index_pos];
index_pos++;
@@ -57,14 +64,17 @@ void librarySort(int *index, int n) {
}
int index_pos_for_output = 0;
for (int i = 0; index_pos_for_output < n; i++) {
if (numbered[i] == true) {
for (int i = 0; index_pos_for_output < n; i++)
{
if (numbered[i] == true)
{
// std::cout << gaps[i] << std::endl;
index[index_pos_for_output] = gaps[i];
index_pos_for_output++;
}
if (i < lib_size) {
if (i < lib_size)
{
// std::cout << library[target_lib][i] << std::endl;
index[index_pos_for_output] = library[target_lib][i];
index_pos_for_output++;
@@ -72,15 +82,15 @@ void librarySort(int *index, int n) {
}
}
int main() {
int main()
{
// ---example--
int index_ex[] = {-6, 5, 9, 1, 9, 1, 0, 1, -8, 4, -12};
int n_ex = sizeof(index_ex) / sizeof(index_ex[0]);
librarySort(index_ex, n_ex);
std::cout << "sorted array :" << std::endl;
for (int i = 0; i < n_ex; i++)
std::cout << index_ex[i] << " ";
for (int i = 0; i < n_ex; i++) std::cout << index_ex[i] << " ";
std::cout << std::endl;
/* --output--

34
sorting/merge_sort.cpp
View File

@@ -1,6 +1,7 @@
#include <iostream>
void merge(int arr[], int l, int m, int r) {
void merge(int arr[], int l, int m, int r)
{
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
@@ -13,24 +14,30 @@ void merge(int arr[], int l, int m, int r) {
i = 0;
j = 0;
k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
} else {
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
while (j < n2)
{
arr[k] = R[j];
j++;
k++;
@@ -40,8 +47,10 @@ void merge(int arr[], int l, int m, int r) {
delete[] R;
}
void mergeSort(int arr[], int l, int r) {
if (l < r) {
void mergeSort(int arr[], int l, int r)
{
if (l < r)
{
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
@@ -51,12 +60,14 @@ void mergeSort(int arr[], int l, int r) {
}
}
void show(int A[], int size) {
void show(int A[], int size)
{
int i;
for (i = 0; i < size; i++) std::cout << A[i] << "\n";
}
int main() {
int main()
{
int size;
std::cout << "\nEnter the number of elements : ";
@@ -66,7 +77,8 @@ int main() {
std::cout << "\nEnter the unsorted elements : ";
for (int i = 0; i < size; ++i) {
for (int i = 0; i < size; ++i)
{
std::cout << "\n";
std::cin >> arr[i];
}

24
sorting/non_recursive_merge_sort.cpp
View File

@@ -22,17 +22,20 @@ void merge(Iterator, Iterator, const Iterator, char[]);
*/
template <class Iterator>
void non_recursive_merge_sort(const Iterator first, const Iterator last,
const size_t n) {
const size_t n)
{
// create a buffer large enough to store all elements
// dynamically allocated to comply with cpplint
char* buffer = new char[n * sizeof(*first)];
// buffer size can be optimized to largest power of 2 less than n elements
// divide the container into equally-sized segments whose length start at 1
// and keeps increasing by factors of 2
for (size_t length(1); length < n; length <<= 1) {
for (size_t length(1); length < n; length <<= 1)
{
// merge adjacent segments whose number is n / (length * 2)
Iterator left(first);
for (size_t counter(n / (length << 1)); counter; --counter) {
for (size_t counter(n / (length << 1)); counter; --counter)
{
Iterator right(left + length), end(right + length);
merge(left, right, end, buffer);
left = end;
@@ -53,7 +56,8 @@ void non_recursive_merge_sort(const Iterator first, const Iterator last,
* @param b points at the buffer
*/
template <class Iterator>
void merge(Iterator l, Iterator r, const Iterator e, char b[]) {
void merge(Iterator l, Iterator r, const Iterator e, char b[])
{
// create 2 pointers to point at the buffer
auto p(reinterpret_cast<std::remove_reference_t<decltype(*l)>*>(b)), c(p);
// move the left part of the segment
@@ -73,7 +77,8 @@ void merge(Iterator l, Iterator r, const Iterator e, char b[]) {
* @param n the number of elements
*/
template <class Iterator>
void non_recursive_merge_sort(const Iterator first, const size_t n) {
void non_recursive_merge_sort(const Iterator first, const size_t n)
{
non_recursive_merge_sort(first, first + n, n);
}
/// bottom-up merge sort which sorts elements in a non-decreasing order
@@ -82,16 +87,19 @@ void non_recursive_merge_sort(const Iterator first, const size_t n) {
* @param last points to 1-step past the last element
*/
template <class Iterator>
void non_recursive_merge_sort(const Iterator first, const Iterator last) {
void non_recursive_merge_sort(const Iterator first, const Iterator last)
{
non_recursive_merge_sort(first, last, last - first);
}
int main(int argc, char** argv) {
int main(int argc, char** argv)
{
int size;
std::cout << "Enter the number of elements : ";
std::cin >> size;
int* arr = new int[size];
for (int i = 0; i < size; ++i) {
for (int i = 0; i < size; ++i)
{
std::cout << "arr[" << i << "] = ";
std::cin >> arr[i];
}

24
sorting/numeric_string_sort.cpp
View File

@@ -13,40 +13,48 @@
#include <string>
#include <vector>
bool NumericSort(std::string a, std::string b) {
while (a[0] == '0') {
bool NumericSort(std::string a, std::string b)
{
while (a[0] == '0')
{
a.erase(a.begin());
}
while (b[0] == '0') {
while (b[0] == '0')
{
b.erase(b.begin());
}
int n = a.length();
int m = b.length();
if (n == m) return a < b;
if (n == m)
return a < b;
return n < m;
}
int main() {
int main()
{
int n;
std::cout << "Enter number of elements to be sorted Numerically\n";
std::cin >> n;
std::vector<std::string> v(n);
std::cout << "Enter the string of Numbers\n";
for (int i = 0; i < n; i++) {
for (int i = 0; i < n; i++)
{
std::cin >> v[i];
}
sort(v.begin(), v.end());
std::cout << "Elements sorted normally \n";
for (int i = 0; i < n; i++) {
for (int i = 0; i < n; i++)
{
std::cout << v[i] << " ";
}
std::cout << "\n";
std::sort(v.begin(), v.end(), NumericSort);
std::cout << "Elements sorted Numerically \n";
for (int i = 0; i < n; i++) {
for (int i = 0; i < n; i++)
{
std::cout << v[i] << " ";
}

75
sorting/odd_even_sort.cpp
View File

@@ -6,56 +6,55 @@ using namespace std;
void oddEven(vector<int> &arr, int size)
{
bool sorted = false;
while (!sorted)
{
sorted = true;
for (int i = 1; i < size - 1; i += 2) //Odd
{
if (arr[i] > arr[i + 1])
{
swap(arr[i], arr[i + 1]);
sorted = false;
}
}
bool sorted = false;
while (!sorted)
{
sorted = true;
for (int i = 1; i < size - 1; i += 2) // Odd
{
if (arr[i] > arr[i + 1])
{
swap(arr[i], arr[i + 1]);
sorted = false;
}
}
for (int i = 0; i < size - 1; i += 2) //Even
{
if (arr[i] > arr[i + 1])
{
swap(arr[i], arr[i + 1]);
sorted = false;
}
}
}
for (int i = 0; i < size - 1; i += 2) // Even
{
if (arr[i] > arr[i + 1])
{
swap(arr[i], arr[i + 1]);
sorted = false;
}
}
}
}
void show(vector<int> A, int size)
{
int i;
for (i = 0; i < size; i++)
cout << A[i] << "\n";
int i;
for (i = 0; i < size; i++) cout << A[i] << "\n";
}
int main()
{
int size, temp;
cout << "\nEnter the number of elements : ";
cin >> size;
int size, temp;
cout << "\nEnter the number of elements : ";
cin >> size;
vector<int> arr;
vector<int> arr;
cout << "\nEnter the unsorted elements : \n";
cout << "\nEnter the unsorted elements : \n";
for (int i = 0; i < size; ++i)
{
cin >> temp;
arr.push_back(temp);
}
for (int i = 0; i < size; ++i)
{
cin >> temp;
arr.push_back(temp);
}
oddEven(arr, size);
oddEven(arr, size);
cout << "Sorted array\n";
show(arr, size);
return 0;
cout << "Sorted array\n";
show(arr, size);
return 0;
}

24
sorting/quick_sort.cpp
View File

@@ -33,14 +33,17 @@
*
*/
int partition(int arr[], int low, int high) {
int partition(int arr[], int low, int high)
{
int pivot = arr[high]; // taking the last element as pivot
int i = (low - 1); // Index of smaller element
for (int j = low; j < high; j++) {
for (int j = low; j < high; j++)
{
// If current element is smaller than or
// equal to pivot
if (arr[j] <= pivot) {
if (arr[j] <= pivot)
{
i++; // increment index of smaller element
int temp = arr[i];
arr[i] = arr[j];
@@ -59,8 +62,10 @@ int partition(int arr[], int low, int high) {
* low --> Starting index,
* high --> Ending index
*/
void quickSort(int arr[], int low, int high) {
if (low < high) {
void quickSort(int arr[], int low, int high)
{
if (low < high)
{
int p = partition(arr, low, high);
quickSort(arr, low, p - 1);
quickSort(arr, p + 1, high);
@@ -68,13 +73,15 @@ void quickSort(int arr[], int low, int high) {
}
// prints the array after sorting
void show(int arr[], int size) {
void show(int arr[], int size)
{
for (int i = 0; i < size; i++) std::cout << arr[i] << " ";
std::cout << "\n";
}
/** Driver program to test above functions */
int main() {
int main()
{
int size;
std::cout << "\nEnter the number of elements : ";
@@ -84,7 +91,8 @@ int main() {
std::cout << "\nEnter the unsorted elements : ";
for (int i = 0; i < size; ++i) {
for (int i = 0; i < size; ++i)
{
std::cout << "\n";
std::cin >> arr[i];
}

39
sorting/radix_sort.cpp
View File

@@ -3,53 +3,66 @@
#include <cstring>
#include <iostream>
void radixsort(int a[], int n) {
void radixsort(int a[], int n)
{
int count[10];
int* output = new int[n];
memset(output, 0, n * sizeof(*output));
memset(count, 0, sizeof(count));
int max = 0;
for (int i = 0; i < n; ++i) {
if (a[i] > max) {
for (int i = 0; i < n; ++i)
{
if (a[i] > max)
{
max = a[i];
}
}
int maxdigits = 0;
while (max) {
while (max)
{
maxdigits++;
max /= 10;
}
for (int j = 0; j < maxdigits; j++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < maxdigits; j++)
{
for (int i = 0; i < n; i++)
{
int t = std::pow(10, j);
count[(a[i] % (10 * t)) / t]++;
}
int k = 0;
for (int p = 0; p < 10; p++) {
for (int i = 0; i < n; i++) {
for (int p = 0; p < 10; p++)
{
for (int i = 0; i < n; i++)
{
int t = std::pow(10, j);
if ((a[i] % (10 * t)) / t == p) {
if ((a[i] % (10 * t)) / t == p)
{
output[k] = a[i];
k++;
}
}
}
memset(count, 0, sizeof(count));
for (int i = 0; i < n; ++i) {
for (int i = 0; i < n; ++i)
{
a[i] = output[i];
}
}
delete[] output;
}
void print(int a[], int n) {
for (int i = 0; i < n; ++i) {
void print(int a[], int n)
{
for (int i = 0; i < n; ++i)
{
std::cout << a[i] << " ";
}
std::cout << std::endl;
}
int main(int argc, char const* argv[]) {
int main(int argc, char const* argv[])
{
int a[] = {170, 45, 75, 90, 802, 24, 2, 66};
int n = sizeof(a) / sizeof(a[0]);
radixsort(a, n);

58
sorting/selection_sort.cpp
View File

@@ -1,39 +1,39 @@
//Selection Sort
// Selection Sort
#include <iostream>
using namespace std;
int main()
{
int Array[6];
cout << "\nEnter any 6 Numbers for Unsorted Array : ";
int Array[6];
cout << "\nEnter any 6 Numbers for Unsorted Array : ";
//Input
for (int i = 0; i < 6; i++)
{
cin >> Array[i];
}
// Input
for (int i = 0; i < 6; i++)
{
cin >> Array[i];
}
//Selection Sorting
for (int i = 0; i < 6; i++)
{
int min = i;
for (int j = i + 1; j < 6; j++)
{
if (Array[j] < Array[min])
{
min = j; //Finding the smallest number in Array
}
}
int temp = Array[i];
Array[i] = Array[min];
Array[min] = temp;
}
// Selection Sorting
for (int i = 0; i < 6; i++)
{
int min = i;
for (int j = i + 1; j < 6; j++)
{
if (Array[j] < Array[min])
{
min = j; // Finding the smallest number in Array
}
}
int temp = Array[i];
Array[i] = Array[min];
Array[min] = temp;
}
//Output
cout << "\nSorted Array : ";
for (int i = 0; i < 6; i++)
{
cout << Array[i] << "\t";
}
// Output
cout << "\nSorted Array : ";
for (int i = 0; i < 6; i++)
{
cout << Array[i] << "\t";
}
}

25
sorting/shell_sort.cpp
View File

@@ -1,23 +1,31 @@
#include <iostream>
int main() {
int main()
{
int size = 10;
int* array = new int[size];
// Input
std::cout << "\nHow many numbers do want to enter in unsorted array : ";
std::cin >> size;
std::cout << "\nEnter the numbers for unsorted array : ";
for (int i = 0; i < size; i++) {
for (int i = 0; i < size; i++)
{
std::cin >> array[i];
}
// Sorting
for (int i = size / 2; i > 0; i = i / 2) {
for (int j = i; j < size; j++) {
for (int k = j - i; k >= 0; k = k - i) {
if (array[k] < array[k + i]) {
for (int i = size / 2; i > 0; i = i / 2)
{
for (int j = i; j < size; j++)
{
for (int k = j - i; k >= 0; k = k - i)
{
if (array[k] < array[k + i])
{
break;
} else {
}
else
{
int temp = array[k + i];
array[k + i] = array[k];
array[k] = temp;
@@ -28,7 +36,8 @@ int main() {
// Output
std::cout << "\nSorted array : ";
for (int i = 0; i < size; ++i) {
for (int i = 0; i < size; ++i)
{
std::cout << array[i] << "\t";
}

141
sorting/shell_sort2.cpp
View File

@@ -6,100 +6,113 @@
// for std::swap
#include <utility>
template <class T> void show_data(T *arr, size_t LEN) {
size_t i;
template <class T>
void show_data(T *arr, size_t LEN)
{
size_t i;
for (i = 0; i < LEN; i++)
std::cout << arr[i] << ", ";
std::cout << std::endl;
for (i = 0; i < LEN; i++) std::cout << arr[i] << ", ";
std::cout << std::endl;
}
template <class T, size_t N> void show_data(T (&arr)[N]) { show_data(arr, N); }
template <class T, size_t N>
void show_data(T (&arr)[N])
{
show_data(arr, N);
}
/**
* Optimized algorithm - takes half the time by utilizing
* Mar
**/
template <class T> void shell_sort(T *arr, size_t LEN) {
const unsigned int gaps[] = {701, 301, 132, 57, 23, 10, 4, 1};
const unsigned int gap_len = 8;
size_t i, j, g;
template <class T>
void shell_sort(T *arr, size_t LEN)
{
const unsigned int gaps[] = {701, 301, 132, 57, 23, 10, 4, 1};
const unsigned int gap_len = 8;
size_t i, j, g;
for (g = 0; g < gap_len; g++) {
unsigned int gap = gaps[g];
for (i = gap; i < LEN; i++) {
T tmp = arr[i];
for (g = 0; g < gap_len; g++)
{
unsigned int gap = gaps[g];
for (i = gap; i < LEN; i++)
{
T tmp = arr[i];
for (j = i; j >= gap && (arr[j - gap] - tmp) > 0; j -= gap)
arr[j] = arr[j - gap];
for (j = i; j >= gap && (arr[j - gap] - tmp) > 0; j -= gap)
arr[j] = arr[j - gap];
arr[j] = tmp;
arr[j] = tmp;
}
}
}
}
template <class T, size_t N> void shell_sort(T (&arr)[N]) {
shell_sort(arr, N);
template <class T, size_t N>
void shell_sort(T (&arr)[N])
{
shell_sort(arr, N);
}
/**
* function to compare sorting using cstdlib's qsort
**/
int compare(const void *a, const void *b) {
int arg1 = *static_cast<const int *>(a);
int arg2 = *static_cast<const int *>(b);
int compare(const void *a, const void *b)
{
int arg1 = *static_cast<const int *>(a);
int arg2 = *static_cast<const int *>(b);
if (arg1 < arg2)
return -1;
if (arg1 > arg2)
return 1;
return 0;
if (arg1 < arg2)
return -1;
if (arg1 > arg2)
return 1;
return 0;
// return (arg1 > arg2) - (arg1 < arg2); // possible shortcut
// return arg1 - arg2; // erroneous shortcut (fails if INT_MIN is present)
// return (arg1 > arg2) - (arg1 < arg2); // possible shortcut
// return arg1 - arg2; // erroneous shortcut (fails if INT_MIN is present)
}
int main(int argc, char *argv[]) {
int i, NUM_DATA;
int main(int argc, char *argv[])
{
int i, NUM_DATA;
if (argc == 2)
NUM_DATA = atoi(argv[1]);
else
NUM_DATA = 200;
if (argc == 2)
NUM_DATA = atoi(argv[1]);
else
NUM_DATA = 200;
// int array = new int[NUM_DATA];
int *data = new int[NUM_DATA];
int *data2 = new int[NUM_DATA];
// int array2 = new int[NUM_DATA];
int range = 1800;
// int array = new int[NUM_DATA];
int *data = new int[NUM_DATA];
int *data2 = new int[NUM_DATA];
// int array2 = new int[NUM_DATA];
int range = 1800;
std::srand(time(NULL));
for (i = 0; i < NUM_DATA; i++)
data[i] = data2[i] = (std::rand() % range) - (range >> 1);
std::srand(time(NULL));
for (i = 0; i < NUM_DATA; i++)
data[i] = data2[i] = (std::rand() % range) - (range >> 1);
std::cout << "Unsorted original data: " << std::endl;
show_data(data, NUM_DATA);
std::clock_t start = std::clock();
shell_sort(data, NUM_DATA);
std::clock_t end = std::clock();
std::cout << "Unsorted original data: " << std::endl;
show_data(data, NUM_DATA);
std::clock_t start = std::clock();
shell_sort(data, NUM_DATA);
std::clock_t end = std::clock();
std::cout << std::endl
<< "Data Sorted using custom implementation: " << std::endl;
show_data(data, NUM_DATA);
std::cout << std::endl
<< "Data Sorted using custom implementation: " << std::endl;
show_data(data, NUM_DATA);
double elapsed_time = (end - start) * 1.f / CLOCKS_PER_SEC;
std::cout << "Time spent sorting: " << elapsed_time << "s\n" << std::endl;
double elapsed_time = (end - start) * 1.f / CLOCKS_PER_SEC;
std::cout << "Time spent sorting: " << elapsed_time << "s\n" << std::endl;
start = std::clock();
qsort(data2, NUM_DATA, sizeof(data2[0]), compare);
end = std::clock();
std::cout << "Data Sorted using cstdlib qsort: " << std::endl;
show_data(data2, NUM_DATA);
start = std::clock();
qsort(data2, NUM_DATA, sizeof(data2[0]), compare);
end = std::clock();
std::cout << "Data Sorted using cstdlib qsort: " << std::endl;
show_data(data2, NUM_DATA);
elapsed_time = (end - start) * 1.f / CLOCKS_PER_SEC;
std::cout << "Time spent sorting: " << elapsed_time << "s\n" << std::endl;
elapsed_time = (end - start) * 1.f / CLOCKS_PER_SEC;
std::cout << "Time spent sorting: " << elapsed_time << "s\n" << std::endl;
free(data);
free(data2);
return 0;
free(data);
free(data2);
return 0;
}

18
sorting/slow_sort.cpp
View File

@@ -10,14 +10,17 @@
#include <iostream>
void SlowSort(int a[], int i, int j) {
if (i >= j) return;
void SlowSort(int a[], int i, int j)
{
if (i >= j)
return;
int m = i + (j - i) / 2; // midpoint, implemented this way to avoid
// overflow
int temp;
SlowSort(a, i, m);
SlowSort(a, m + 1, j);
if (a[j] < a[m]) {
if (a[j] < a[m])
{
temp = a[j]; // swapping a[j] & a[m]
a[j] = a[m];
a[m] = temp;
@@ -27,7 +30,8 @@ void SlowSort(int a[], int i, int j) {
// Sample Main function
int main() {
int main()
{
int size;
std::cout << "\nEnter the number of elements : ";
@@ -37,7 +41,8 @@ int main() {
std::cout << "\nEnter the unsorted elements : ";
for (int i = 0; i < size; ++i) {
for (int i = 0; i < size; ++i)
{
std::cout << "\n";
std::cin >> arr[i];
}
@@ -46,7 +51,8 @@ int main() {
std::cout << "Sorted array\n";
for (int i = 0; i < size; ++i) {
for (int i = 0; i < size; ++i)
{
std::cout << arr[i] << " ";
}

21
sorting/swap_sort.cpp
View File

@@ -6,12 +6,14 @@
// Function returns the minimum number of swaps
// required to sort the array
int minSwaps(int arr[], int n) {
int minSwaps(int arr[], int n)
{
// Create an array of pairs where first
// element is array element and second element
// is position of first element
std::pair<int, int> *arrPos = new std::pair<int, int>[n];
for (int i = 0; i < n; i++) {
for (int i = 0; i < n; i++)
{
arrPos[i].first = arr[i];
arrPos[i].second = i;
}
@@ -29,16 +31,19 @@ int minSwaps(int arr[], int n) {
int ans = 0;
// Traverse array elements
for (int i = 0; i < n; i++) {
for (int i = 0; i < n; i++)
{
// already swapped and corrected or
// already present at correct pos
if (vis[i] || arrPos[i].second == i) continue;
if (vis[i] || arrPos[i].second == i)
continue;
// find out the number of node in
// this cycle and add in ans
int cycle_size = 0;
int j = i;
while (!vis[j]) {
while (!vis[j])
{
vis[j] = 1;
// move to next node
@@ -47,7 +52,8 @@ int minSwaps(int arr[], int n) {
}
// Update answer by adding current cycle.
if (cycle_size > 0) {
if (cycle_size > 0)
{
ans += (cycle_size - 1);
}
}
@@ -59,7 +65,8 @@ int minSwaps(int arr[], int n) {
}
// program to test
int main() {
int main()
{
int arr[] = {6, 7, 8, 1, 2, 3, 9, 12};
int n = (sizeof(arr) / sizeof(int));
std::cout << minSwaps(arr, n);

43
sorting/tim_sort.cpp
View File

@@ -6,11 +6,14 @@ const int RUN = 32;
// this function sorts array from left index to to right index which is of size
// atmost RUN
void insertionSort(int arr[], int left, int right) {
for (int i = left + 1; i <= right; i++) {
void insertionSort(int arr[], int left, int right)
{
for (int i = left + 1; i <= right; i++)
{
int temp = arr[i];
int j = i - 1;
while (arr[j] > temp && j >= left) {
while (arr[j] > temp && j >= left)
{
arr[j + 1] = arr[j];
j--;
}
@@ -19,7 +22,8 @@ void insertionSort(int arr[], int left, int right) {
}
// merge function merges the sorted runs
void merge(int arr[], int l, int m, int r) {
void merge(int arr[], int l, int m, int r)
{
// original array is broken in two parts, left and right array
int len1 = m - l + 1, len2 = r - m;
int *left = new int[len1], *right = new int[len2];
@@ -31,11 +35,15 @@ void merge(int arr[], int l, int m, int r) {
int k = l;
// after comparing, we merge those two array in larger sub array
while (i < len1 && j < len2) {
if (left[i] <= right[j]) {
while (i < len1 && j < len2)
{
if (left[i] <= right[j])
{
arr[k] = left[i];
i++;
} else {
}
else
{
arr[k] = right[j];
j++;
}
@@ -43,14 +51,16 @@ void merge(int arr[], int l, int m, int r) {
}
// copy remaining elements of left, if any
while (i < len1) {
while (i < len1)
{
arr[k] = left[i];
k++;
i++;
}
// copy remaining element of right, if any
while (j < len2) {
while (j < len2)
{
arr[k] = right[j];
k++;
j++;
@@ -60,18 +70,21 @@ void merge(int arr[], int l, int m, int r) {
}
// iterative Timsort function to sort the array[0...n-1] (similar to merge sort)
void timSort(int arr[], int n) {
void timSort(int arr[], int n)
{
// Sort individual subarrays of size RUN
for (int i = 0; i < n; i += RUN)
insertionSort(arr, i, std::min((i + 31), (n - 1)));
// start merging from size RUN (or 32). It will merge to form size 64, then
// 128, 256 and so on ....
for (int size = RUN; size < n; size = 2 * size) {
for (int size = RUN; size < n; size = 2 * size)
{
// pick starting point of left sub array. We are going to merge
// arr[left..left+size-1] and arr[left+size, left+2*size-1] After every
// merge, we increase left by 2*size
for (int left = 0; left < n; left += 2 * size) {
for (int left = 0; left < n; left += 2 * size)
{
// find ending point of left sub array
// mid+1 is starting point of right sub array
int mid = left + size - 1;
@@ -84,13 +97,15 @@ void timSort(int arr[], int n) {
}
// utility function to print the Array
void printArray(int arr[], int n) {
void printArray(int arr[], int n)
{
for (int i = 0; i < n; i++) printf("%d ", arr[i]);
std::cout << std::endl;
}
// Driver program to test above function
int main() {
int main()
{
int arr[] = {5, 21, 7, 23, 19};
int n = sizeof(arr) / sizeof(arr[0]);
printf("Given Array is\n");