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

Major rework to improve code quality and add automation checks (#805)

Browse Source 
* delete secant method - it is identical to regula falsi

* document + improvize root finding algorithms

* attempt to document gaussian elimination

* added file brief

* commented doxygen-mainpage, added files-list link

* corrected files list link path

* files-list link correction - this time works :)

* document successive approximations

* cleaner equation

* updating DIRECTORY.md

* documented kmp string search

* document brute force string search

* document rabin-karp string search

* fixed mainpage readme

* doxygen v1.8.18 will suppress out the #minipage in the markdown

* cpplint correction for header guard style

* github action to auto format source code per cpplint standard

* updated setting to add 1 space before `private` and `public` keywords

* auto rename files and auto format code

* added missing "run" for step

* corrected asignmemt operation

* fixed trim and assign syntax

* added git move for renaming bad filenames

* added missing pipe for trim

* added missing space

* use old and new fnames

* store old fname using echo

* move files only if there is a change in filename

* put old filenames in quotes

* use double quote for old filename

* escape double quotes

* remove old_fname

* try escape characters and echo"

* add file-type to find

* cleanup echo

* ensure all trim variables are also in quotes

* try escape -quote again

* remove second escpe quote

* use single quote for first check

* use carets instead of quotes

* put variables in brackets

* remove -e from echo

* add debug echos

* try print0 flag

* find command with while instead of for-loop

* find command using IFS instead

* 🎉 IFS fix worked - escaped quotes for git mv

* protetc each word in git mv ..

* filename exists in lower cases - renamed

* 🎉 git push enabled

* updating DIRECTORY.md

* git pull & then push

* formatting filenames d7af6fdc8c

* formatting source-code for d7af6fdc8c

* remove allman break before braces

* updating DIRECTORY.md

* added missing comma lost in previous commit

* orchestrate all workflows

* fix yml indentation

* force push format changes, add title to DIRECTORY.md

* pull before proceeding

* reorganize pull commands

* use master branches for actions

* rename .cc files to .cpp

* added class destructor to clean up dynamic memory allocation

* rename to awesome workflow

* commented whole repo cpplint - added modified files lint check

* removed need for cpplint

* attempt to use actions/checkout@master

* temporary: no dependency on cpplint

* formatting filenames 153fb7b8a5

* formatting source-code for 153fb7b8a5

* updating DIRECTORY.md

* fix diff filename

* added comments to the code

* added test case

* formatting source-code for a850308fba

* updating DIRECTORY.md

* added machine learning folder

* added adaline algorithm

* updating DIRECTORY.md

* fixed issue [LWG2192](https://cplusplus.github.io/LWG/issue2192) for std::abs on MacOS

* add cmath for same bug: [LWG2192](https://cplusplus.github.io/LWG/issue2192) for std::abs on MacOS

* formatting source-code for f8925e4822

* use STL's inner_product

* formatting source-code for f94a330594

* added range comments

* define activation function

* use equal initial weights

* change test2 function to predict

* activation function not friend

* previous commit correction

* added option for predict function to return value before applying activation function as optional argument

* added test case to classify points lying within a sphere

* improve documentation for adaline

* formatting source-code for 15ec4c3aba

* added cmake to geometry folder

* added algorithm include for std::max

* add namespace - machine_learning

* add namespace - statistics

* add namespace - sorting

* added sorting algos to namespace sorting

* added namespace string_search

* formatting source-code for fd69530515

* added documentation to string_search namespace

* feat: Add BFS and DFS algorithms to check for cycle in a directed graph

* Remove const references for input of simple types

Reason: overhead on access

* fix bad code

sorry for force push

* Use pointer instead of the non-const reference

because apparently google says so.

* Remove a useless and possibly bad Graph constuctor overload

* Explicitely specify type of vector during graph instantiation

* updating DIRECTORY.md

* find openMP before adding subdirectories

* added kohonen self organizing map

* updating DIRECTORY.md

* remove older files and folders from gh-pages before adding new files

* remove chronos library due to inacceptability by cpplint

* use c++ specific static_cast instead

* initialize radom number generator

* updated image links with those from CPP repository

* rename computer.... folder to numerical methods

* added durand kerner method for root computation for arbitrarily large polynomials

* fixed additional comma

* fix cpplint errors

* updating DIRECTORY.md

* convert to function module

* update documentation

* move openmp to main loop

* added two test cases

* use INT16_MAX

* remove return statement from omp-for loop and use "break"

* run tests when no input is provided and skip tests when input polynomial is provided

* while loop cannot have break - replaced with continue and check is present in the main while condition

* (1) break while loop (2) skip runs on break_loop instead of hard-break

* add documentation images

* use long double for errors and tolerance checks

* make iterator variable i local to threads

* add critical secions to omp threads

* bugfix: move file writing outside of the parallel loop
othersie, there is no gurantee of the order of roots written to file

* rename folder to data_structures

* updating DIRECTORY.md

* fix ambiguous symbol `size`

* add data_structures to cmake

* docs: enable tree view, add timestamp in footer, try clang assistaed parsing

* doxygen - open links in external window

* remove invalid parameter from function docs

* use HTML5 img tag to resize images

* move file to proper folder

* fix documentations and cpplint

* formatting source-code for aacaf9828c

* updating DIRECTORY.md

* cpplint: add braces for multiple statement if

* add explicit link to badges

* remove  duplicate line

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* remove namespace indentation

* remove file associations in settings

* add author name

* enable cmake in subfolders of data_structures

* create and link object file

* cpp lint fixes and instantiate template classes

* cpp lint fixes and instantiate template classes

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* cpplint - ignore `build/include`

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* disable redundant gcc compilation in cpplint workflow

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* template header files contain function codes as well and removed redundant subfolders

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* updating DIRECTORY.md

* remove semicolons after functions in a class

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* cpplint header guard style

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* remove semilon

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* added LU decomposition algorithm

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* added QR decomposition algorithm

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* use QR decomposition to find eigen values

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* updating DIRECTORY.md

* use std::rand for thread safety

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* move srand to main()

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* cpplint braces correction

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* updated eigen value documentation

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* fix matrix shift doc

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* rename CONTRIBUTION.md to CONTRIBUTING.md #836

* remove 'sort alphabetical order' check

* added documentation check

* remove extra paranthesis

* added gitpod

* added gitpod link from README

* attempt to add vscode gitpod extensions

* update gitpod extensions

* add gitpod extensions cmake-tools and git-graph

* remove gitpod init and add commands

* use init to one time install doxygen, graphviz, cpplint

* use gitpod dockerfile

* add ninja build system to docker

* remove configure task

* add github prebuild specs to gitpod

* disable gitpod addcommit

* update documentation for kohonen_som

* added ode solve using forward euler method

* added mid-point euler ode solver

* fixed itegration step equation

* added semi-implicit euler ODE solver

* updating DIRECTORY.md

* fix cpplint issues - lines 117 and 124

* added documentation to ode group

* corrected semi-implicit euler function

* updated docs and test cases better structure

* replace `free` with `delete` operator

* formatting source-code for f55ab50cf2

* updating DIRECTORY.md

* main function must return

* added machine learning group

* added kohonen som topology algorithm

* fix graph image path

* updating DIRECTORY.md

* fix braces

* use snprintf instead of sprintf

* use static_cast

* hardcode character buffer size

* fix machine learning groups in documentation

* fix missing namespace function

* replace kvedala fork references to TheAlgorithms

* fix bug in counting_sort

Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Co-authored-by: Anmol3299 <mittalanmol22@gmail.com>
This commit is contained in:
Krishna Vedala
2020-06-19 12:04:56 -04:00
committed by GitHub
parent 70a2aeedc3
commit aaa08b0150
313 changed files with 49332 additions and 9833 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
sorting/BeadSort.cpp
View File

@@ -1,63 +0,0 @@
// C++ program to implement gravity/bead sort
#include <stdio.h>
#include <string.h>
using namespace std;
#define BEAD(i, j) beads[i * max + j]
// function to perform the above algorithm
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];
// allocating memory
unsigned char beads[max*len];
memset(beads, 0, sizeof(beads));
// mark the beads
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++)
{
// count how many beads are on each post
int sum = 0;
for (int i=0; i < len; i++)
{
sum += BEAD(i, j);
BEAD(i, j) = 0;
}
// Move beads down
for (int i = len - sum; i < len; i++)
BEAD(i, j) = 1;
}
// Put sorted values in array using beads
for (int i = 0; i < len; i++)
{
int j;
for (j = 0; j < max && BEAD(i, j); j++);
a[i] = j;
}
}
// driver function to test the algorithm
int main()
{
int a[] = {5, 3, 1, 7, 4, 1, 1, 20};
int len = sizeof(a)/sizeof(a[0]);
beadSort(a, len);
for (int i = 0; i < len; i++)
printf("%d ", a[i]);
return 0;
}

76
sorting/BitonicSort.cpp
View File

@@ -1,76 +0,0 @@
// Source : https://www.geeksforgeeks.org/bitonic-sort/
/* C++ Program for Bitonic Sort. Note that this program
works only when size of input is a power of 2. */
#include <stdio.h>
#include <algorithm.h>
using namespace std;
/*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]))
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)
{
int k = cnt / 2;
for (int i = low; i < low + k; i++)
compAndSwap(a, i, i + k, dir);
bitonicMerge(a, low, k, dir);
bitonicMerge(a, low + k, k, 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)
{
int k = cnt / 2;
// sort in ascending order since dir here is 1
bitonicSort(a, low, k, 1);
// sort in descending order since dir here is 0
bitonicSort(a, low + k, k, 0);
// Will merge wole sequence in ascending order
// since dir=1.
bitonicMerge(a, low, cnt, dir);
}
}
/* Caller of bitonicSort for sorting the entire array of
length N in ASCENDING order */
void sort(int a[], int N, int up)
{
bitonicSort(a, 0, N, up);
}
// Driver code
int main()
{
int a[] = {3, 7, 4, 8, 6, 2, 1, 5};
int N = sizeof(a) / sizeof(a[0]);
int up = 1; // means sort in ascending order
sort(a, N, up);
printf("Sorted array: \n");
for (int i = 0; i < N; i++)
printf("%d ", a[i]);
return 0;
}

83
sorting/Bubble Sort.cpp
View File

@@ -1,83 +0,0 @@
//Bubble Sort
#include <iostream>
#include <vector>
using namespace std;
int main()
{
int n;
short swap_check = 1;
cout << "Enter the amount of numbers to sort: ";
cin >> n;
vector<int> numbers;
cout << "Enter " << n << " numbers: ";
int num;
//Input
for (int i = 0; i < n; i++)
{
cin >> num;
numbers.push_back(num);
}
//Bubble Sorting
for (int i = 0; (i < n) && (swap_check == 1); i++)
{
swap_check = 0;
for (int j = 0; j < n - 1 - i; j++)
{
if (numbers[j] > numbers[j + 1])
{
swap_check = 1;
swap(numbers[j], numbers[j + 1]);// by changing swap location. I mean, j. If the number is greater than j + 1, then it means the location.
}
}
}
//Output
cout << "\nSorted Array : ";
for (int i = 0; i < numbers.size(); i++)
{
if (i != numbers.size() - 1)
{
cout << numbers[i] << ", ";
}
else
{
cout << numbers[i] << endl;
}
}
return 0;
}
/*The working principle of the Bubble sort algorithm:
Bubble sort algorithm is the bubble sorting algorithm. The most important reason for calling the bubble is that the largest number is thrown at the end of this algorithm.
This is all about the logic.
In each iteration, the largest number is expired and when iterations are completed, the sorting takes place.
What is Swap?
Swap in the software means that two variables are displaced.
An additional variable is required for this operation. x = 5, y = 10.
We want x = 10, y = 5. Here we create the most variable to do it.
int z;
z = x;
x = y;
y = z;
The above process is a typical displacement process.
When x assigns the value to x, the old value of x is lost.
That's why we created a variable z to create the first value of the value of x, and finally, we have assigned to y.
Bubble Sort Algorithm Analysis (Best Case - Worst Case - Average Case)
Bubble Sort Worst Case Performance is O (n²). Why is that? Because if you remember Big O Notation, we were calculating the complexity of the algorithms in the nested loops.
The n * (n - 1) product gives us O (n²) performance. In the worst case all the steps of the cycle will occur.
Bubble Sort (Avarage Case) Performance. Bubble Sort is not an optimal algorithm.
in average, O (n²) performance is taken.
Bubble Sort Best Case Performance. O (n).
However, you can't get the best status in the code we shared above. This happens on the optimized bubble sort algorithm. It's right down there.
* /

20
sorting/CMakeLists.txt Normal file
View File

@@ -0,0 +1,20 @@
# If necessary, use the RELATIVE flag, otherwise each source file may be listed
# with full pathname. RELATIVE may makes it easier to extract an executable name
# automatically.
file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp )
# file( GLOB APP_SOURCES ${CMAKE_SOURCE_DIR}/*.c )
# AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} APP_SOURCES)
foreach( testsourcefile ${APP_SOURCES} )
# I used a simple string replace, to cut off .cpp.
string( REPLACE ".cpp" "" testname ${testsourcefile} )
add_executable( ${testname} ${testsourcefile} )
set_target_properties(${testname} PROPERTIES
LINKER_LANGUAGE CXX
CXX_STANDARD 14)
if(OpenMP_CXX_FOUND)
target_link_libraries(${testname} OpenMP::OpenMP_CXX)
endif()
install(TARGETS ${testname} DESTINATION "bin/sorting")
endforeach( testsourcefile ${APP_SOURCES} )

109
sorting/CocktailSelectionSort.cpp
View File

@@ -1,109 +0,0 @@
//Returns Sorted elements after performing Cocktail Selection Sort
//It is a Sorting algorithm which chooses the minimum and maximum element in an array simultaneously,
//and swaps it with the lowest and highest available position iteratively or recursively
#include <iostream>
using namespace std;
//Iterative Version
void CocktailSelectionSort(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)
{
maximum = vec[i];
maximumindex = i;
}
if (vec[i] <= minimum)
{
minimum = vec[i];
minimumindex = i;
}
}
if (low != maximumindex || high != minimumindex)
{
swap(vec[low], vec[minimumindex]);
swap(vec[high], vec[maximumindex]);
}
else
{
swap(vec[low], vec[high]);
}
low++;
high--;
}
}
//Recursive Version
void CocktailSelectionSort(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)
{
maximum = vec[i];
maximumindex = i;
}
if (vec[i] <= minimum)
{
minimum = vec[i];
minimumindex = i;
}
}
if (low != maximumindex || high != minimumindex)
{
swap(vec[low], vec[minimumindex]);
swap(vec[high], vec[maximumindex]);
}
else
{
swap(vec[low], vec[high]);
}
CocktailSelectionSort(vec, low + 1, high - 1);
}
//main function, select any one of iterative or recursive version
int main()
{
int n;
cout << "Enter number of elements\n";
cin >> n;
std::vector<int> v(n);
cout << "Enter all the elements\n";
for (int i = 0; i < n; ++i)
{
cin >> v[i];
}
CocktailSelectionSort(v, 0, n - 1);
cout << "Sorted elements are\n";
for (int i = 0; i < n; ++i)
{
cout << v[i] << " ";
}
return 0;
}

66
sorting/Counting_Sort.cpp
View File

@@ -1,66 +0,0 @@
#include <iostream>
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 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;
}
void Print(int Arr[], int N)
{
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 *Count = new int[max - min + 1];
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 = N - 1; i >= 0; i--)
{
Sorted_Arr[Count[Arr[i] - min] - 1] = Arr[i];
Count[Arr[i] - min]--;
}
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;
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;
}

40
sorting/Insertion Sort.cpp
View File

@@ -1,40 +0,0 @@
//Insertion Sort
#include <iostream>
using namespace std;
int main()
{
int n;
cout << "\nEnter the length of your array : ";
cin >> n;
int Array[n];
cout << "\nEnter any " << n << " Numbers for Unsorted Array : ";
//Input
for (int i = 0; i < n; i++)
{
cin >> Array[i];
}
//Sorting
for (int i = 1; i < n; i++)
{
int temp = Array[i];
int j = i - 1;
while (j >= 0 && temp < Array[j])
{
Array[j + 1] = Array[j];
j--;
}
Array[j + 1] = temp;
}
//Output
cout << "\nSorted Array : ";
for (int i = 0; i < n; i++)
{
cout << Array[i] << "\t";
}
return 0;
}

93
sorting/Merge Sort.cpp
View File

@@ -1,93 +0,0 @@
#include <iostream>
using namespace std;
void merge(int arr[], int l, int m, int r)
{
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1 + j];
i = 0;
j = 0;
k = l;
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(int arr[], int l, int r)
{
if (l < r)
{
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
void show(int A[], int size)
{
int i;
for (i = 0; i < size; i++)
cout << A[i] << "\n";
}
int main()
{
int size;
cout << "\nEnter the number of elements : ";
cin >> size;
int arr[size];
cout << "\nEnter the unsorted elements : ";
for (int i = 0; i < size; ++i)
{
cout << "\n";
cin >> arr[i];
}
mergeSort(arr, 0, size);
cout << "Sorted array\n";
show(arr, size);
return 0;
}

62
sorting/NumericStringSort.cpp
View File

@@ -1,62 +0,0 @@
//Using general algorithms to sort a collection of strings results in alphanumeric sort.
//If it is a numeric string, it leads to unnatural sorting
//eg, an array of strings 1,10,100,2,20,200,3,30,300
//would be sorted in that same order by using conventional sorting,
//even though we know the correct sorting order is 1,2,3,10,20,30,100,200,300
//This Programme uses a comparator to sort the array in Numerical order instead of Alphanumeric order
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
bool NumericSort(string a, string b)
{
while (a[0] == '0')
{
a.erase(a.begin());
}
while (b[0] == '0')
{
b.erase(b.begin());
}
int n = a.length();
int m = b.length();
if (n == m)
return a < b;
return n < m;
}
int main()
{
int n;
cout << "Enter number of elements to be sorted Numerically\n";
cin >> n;
vector<string> v(n);
cout << "Enter the string of Numbers\n";
for (int i = 0; i < n; i++)
{
cin >> v[i];
}
sort(v.begin(), v.end());
cout << "Elements sorted normally \n";
for (int i = 0; i < n; i++)
{
cout << v[i] << " ";
}
cout << "\n";
sort(v.begin(), v.end(), NumericSort);
cout << "Elements sorted Numerically \n";
for (int i = 0; i < n; i++)
{
cout << v[i] << " ";
}
return 0;
}

61
sorting/OddEven Sort.cpp
View File

@@ -1,61 +0,0 @@
/* C++ implementation Odd Even Sort */
#include <iostream>
#include <vector>
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;
}
}
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 main()
{
int size, temp;
cout << "\nEnter the number of elements : ";
cin >> size;
vector<int> arr;
cout << "\nEnter the unsorted elements : \n";
for (int i = 0; i < size; ++i)
{
cin >> temp;
arr.push_back(temp);
}
oddEven(arr, size);
cout << "Sorted array\n";
show(arr, size);
return 0;
}

68
sorting/Radix Sort.cpp
View File

@@ -1,68 +0,0 @@
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
void radixsort(int a[], int n)
{
int count[10];
int output[n];
memset(output, 0, sizeof(output));
memset(count, 0, sizeof(count));
int max = 0;
for (int i = 0; i < n; ++i)
{
if (a[i] > max)
{
max = a[i];
}
}
int maxdigits = 0;
while (max)
{
maxdigits++;
max /= 10;
}
for (int j = 0; j < maxdigits; j++)
{
for (int i = 0; i < n; i++)
{
int t = 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++)
{
int t = pow(10, j);
if ((a[i] % (10 * t)) / t == p)
{
output[k] = a[i];
k++;
}
}
}
memset(count, 0, sizeof(count));
for (int i = 0; i < n; ++i)
{
a[i] = output[i];
}
}
}
void print(int a[], int n)
{
for (int i = 0; i < n; ++i)
{
cout << a[i] << " ";
}
cout << endl;
}
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);
print(a, n);
return 0;
}

39
sorting/Selection Sort.cpp
View File

@@ -1,39 +0,0 @@
//Selection Sort
#include <iostream>
using namespace std;
int main()
{
int Array[6];
cout << "\nEnter any 6 Numbers for Unsorted Array : ";
//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;
}
//Output
cout << "\nSorted Array : ";
for (int i = 0; i < 6; i++)
{
cout << Array[i] << "\t";
}
}

45
sorting/Shell Sort.cpp
View File

@@ -1,45 +0,0 @@
#include <iostream>
using namespace std;
int main()
{
int size = 10;
int array[size];
// Input
cout << "\nHow many numbers do want to enter in unsorted array : ";
cin >> size;
cout << "\nEnter the numbers for unsorted array : ";
for (int i = 0; i < size; i++)
{
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])
{
break;
}
else
{
int temp = array[k + i];
array[k + i] = array[k];
array[k] = temp;
}
}
}
}
// Output
cout << "\nSorted array : ";
for (int i = 0; i < size; ++i)
{
cout << array[i] << "\t";
}
return 0;
}

57
sorting/Slow Sort.cpp
View File

@@ -1,57 +0,0 @@
//Returns the sorted vector after performing SlowSort
//It is a sorting algorithm that is of humorous nature and not useful.
//It's based on the principle of multiply and surrender, a tongue-in-cheek joke of divide and conquer.
//It was published in 1986 by Andrei Broder and Jorge Stolfi in their paper Pessimal Algorithms and Simplexity Analysis.
//This algorithm multiplies a single problem into multiple subproblems
//It is interesting because it is provably the least efficient sorting algorithm that can be built asymptotically,
//and with the restriction that such an algorithm, while being slow, must still all the time be working towards a result.
#include <iostream>
using namespace std;
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])
{
temp = a[j]; //swapping a[j] & a[m]
a[j] = a[m];
a[m] = temp;
}
SlowSort(a, i, j - 1);
}
//Sample Main function
int main()
{
int size;
cout << "\nEnter the number of elements : ";
cin >> size;
int arr[size];
cout << "\nEnter the unsorted elements : ";
for (int i = 0; i < size; ++i)
{
cout << "\n";
cin >> arr[i];
}
SlowSort(arr, 0, size);
cout << "Sorted array\n";
for (int i = 0; i < size; ++i)
{
cout << arr[i] << " ";
}
return 0;
}

56
sorting/bead_sort.cpp Normal file
View File

@@ -0,0 +1,56 @@
// C++ program to implement gravity/bead sort
#include <cstdio>
#include <cstring>
#define BEAD(i, j) beads[i * max + j]
// function to perform the above algorithm
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];
// allocating memory
unsigned char *beads = new unsigned char[max * len];
memset(beads, 0, max * len);
// mark the beads
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++) {
// count how many beads are on each post
int sum = 0;
for (int i = 0; i < len; i++) {
sum += BEAD(i, j);
BEAD(i, j) = 0;
}
// Move beads down
for (int i = len - sum; i < len; i++) BEAD(i, j) = 1;
}
// Put sorted values in array using beads
for (int i = 0; i < len; i++) {
int j;
for (j = 0; j < max && BEAD(i, j); j++) {
}
a[i] = j;
}
delete[] beads;
}
// driver function to test the algorithm
int main() {
int a[] = {5, 3, 1, 7, 4, 1, 1, 20};
int len = sizeof(a) / sizeof(a[0]);
beadSort(a, len);
for (int i = 0; i < len; i++) printf("%d ", a[i]);
return 0;
}

64
sorting/bitonic_sort.cpp Normal file
View File

@@ -0,0 +1,64 @@
// Source : https://www.geeksforgeeks.org/bitonic-sort/
/* C++ Program for Bitonic Sort. Note that this program
works only when size of input is a power of 2. */
#include <algorithm>
#include <iostream>
/*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]);
}
/*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) {
int k = cnt / 2;
for (int i = low; i < low + k; i++) compAndSwap(a, i, i + k, dir);
bitonicMerge(a, low, k, dir);
bitonicMerge(a, low + k, k, 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) {
int k = cnt / 2;
// sort in ascending order since dir here is 1
bitonicSort(a, low, k, 1);
// sort in descending order since dir here is 0
bitonicSort(a, low + k, k, 0);
// Will merge wole sequence in ascending order
// since dir=1.
bitonicMerge(a, low, cnt, dir);
}
}
/* Caller of bitonicSort for sorting the entire array of
length N in ASCENDING order */
void sort(int a[], int N, int up) { bitonicSort(a, 0, N, up); }
// Driver code
int main() {
int a[] = {3, 7, 4, 8, 6, 2, 1, 5};
int N = sizeof(a) / sizeof(a[0]);
int up = 1; // means sort in ascending order
sort(a, N, up);
std::cout << "Sorted array: \n";
for (int i = 0; i < N; i++) std::cout << a[i] << " ";
return 0;
}

83
sorting/bubble_sort.cpp Normal file
View File

@@ -0,0 +1,83 @@
/**
* @file
* @brief Bubble sort algorithm
*
* The working principle of the Bubble sort algorithm:
Bubble sort algorithm is the bubble sorting algorithm. The most important reason
for calling the bubble is that the largest number is thrown at the end of this
algorithm. This is all about the logic. In each iteration, the largest number is
expired and when iterations are completed, the sorting takes place.
What is Swap?
Swap in the software means that two variables are displaced.
An additional variable is required for this operation. x = 5, y = 10.
We want x = 10, y = 5. Here we create the most variable to do it.
int z;
z = x;
x = y;
y = z;
The above process is a typical displacement process.
When x assigns the value to x, the old value of x is lost.
That's why we created a variable z to create the first value of the value of x,
and finally, we have assigned to y.
Bubble Sort Algorithm Analysis (Best Case - Worst Case - Average Case)
Bubble Sort Worst Case Performance is O (n²). Why is that? Because if you
remember Big O Notation, we were calculating the complexity of the algorithms in
the nested loops. The n * (n - 1) product gives us O (n²) performance. In the
worst case all the steps of the cycle will occur. Bubble Sort (Avarage Case)
Performance. Bubble Sort is not an optimal algorithm. in average, O (n²)
performance is taken. Bubble Sort Best Case Performance. O (n). However, you
can't get the best status in the code we shared above. This happens on the
optimized bubble sort algorithm. It's right down there.
*/
#include <iostream>
#include <vector>
int main() {
int n;
bool swap_check = true;
std::cout << "Enter the amount of numbers to sort: ";
std::cin >> n;
std::vector<int> numbers;
std::cout << "Enter " << n << " numbers: ";
int num;
// Input
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++) {
swap_check = false;
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.
// I mean, j. If the number is
// greater than j + 1, then it
// means the location.
}
}
}
// Output
std::cout << "\nSorted Array : ";
for (int i = 0; i < numbers.size(); i++) {
if (i != numbers.size() - 1) {
std::cout << numbers[i] << ", ";
} else {
std::cout << numbers[i] << std::endl;
}
}
return 0;
}

42
sorting/bucketSort.cpp
View File

@@ -1,42 +0,0 @@
// C++ program to sort an array using bucket sort
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
// Function to sort arr[] of size n using bucket sort
void bucketSort(float arr[], int n)
{
// 1) Create n empty buckets
vector<float> b[n];
// 2) Put array elements in different buckets
for (int i = 0; i < n; i++)
{
int bi = n * arr[i]; // Index in bucket
b[bi].push_back(arr[i]);
}
// 3) Sort individual buckets
for (int i = 0; i < n; i++)
sort(b[i].begin(), b[i].end());
// 4) Concatenate all buckets into arr[]
int index = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < b[i].size(); j++)
arr[index++] = b[i][j];
}
/* Driver program to test above funtion */
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);
cout << "Sorted array is \n";
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
return 0;
}

36
sorting/bucket_sort.cpp Normal file
View File

@@ -0,0 +1,36 @@
// C++ program to sort an array using bucket sort
#include <algorithm>
#include <iostream>
#include <vector>
// Function to sort arr[] of size n using bucket sort
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++) {
int bi = n * arr[i]; // Index in bucket
b[bi].push_back(arr[i]);
}
// 3) Sort individual buckets
for (int i = 0; i < n; i++) std::sort(b[i].begin(), b[i].end());
// 4) Concatenate all buckets into arr[]
int index = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < b[i].size(); j++) arr[index++] = b[i][j];
delete[] b;
}
/* Driver program to test above funtion */
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);
std::cout << "Sorted array is \n";
for (int i = 0; i < n; i++) std::cout << arr[i] << " ";
return 0;
}

102
sorting/cocktail_selection_sort.cpp Normal file
View File

@@ -0,0 +1,102 @@
// Returns Sorted elements after performing Cocktail Selection Sort
// It is a Sorting algorithm which chooses the minimum and maximum element in an
// array simultaneously, and swaps it with the lowest and highest available
// position iteratively or recursively
#include <algorithm>
#include <iostream>
#include <vector>
// Iterative Version
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) {
maximum = (*vec)[i];
maximumindex = i;
}
if ((*vec)[i] <= minimum) {
minimum = (*vec)[i];
minimumindex = i;
}
}
if (low != maximumindex || high != minimumindex) {
std::swap((*vec)[low], (*vec)[minimumindex]);
std::swap((*vec)[high], (*vec)[maximumindex]);
} else {
std::swap((*vec)[low], (*vec)[high]);
}
low++;
high--;
}
}
// Recursive Version
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) {
maximum = (*vec)[i];
maximumindex = i;
}
if ((*vec)[i] <= minimum) {
minimum = (*vec)[i];
minimumindex = i;
}
}
if (low != maximumindex || high != minimumindex) {
std::swap((*vec)[low], (*vec)[minimumindex]);
std::swap((*vec)[high], (*vec)[maximumindex]);
} else {
std::swap((*vec)[low], (*vec)[high]);
}
CocktailSelectionSort(vec, low + 1, high - 1);
}
// main function, select any one of iterative or recursive version
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) {
std::cin >> v[i];
}
int method;
std::cout << "Enter method: \n\t0: iterative\n\t1: recursive:\t";
std::cin >> method;
if (method == 0) {
CocktailSelectionSort(&v, 0, n - 1);
} else if (method == 1) {
CocktailSelectionSort_v2(&v, 0, n - 1);
} else {
std::cerr << "Unknown method" << std::endl;
return -1;
}
std::cout << "Sorted elements are\n";
for (int i = 0; i < n; ++i) {
std::cout << v[i] << " ";
}
return 0;
}

49
sorting/comb_sort.cpp Normal file
View File

@@ -0,0 +1,49 @@
// Kind of better version of Bubble sort.
// While Bubble sort is comparering adjacent value, Combsort is using gap larger
// than 1 Best case: O(n) Worst case: O(n ^ 2)
#include <algorithm>
#include <iostream>
int a[100005];
int n;
int FindNextGap(int x) {
x = (x * 10) / 13;
return std::max(1, x);
}
void CombSort(int a[], int l, int r) {
// Init gap
int gap = n;
// Initialize swapped as true to make sure that loop runs
bool swapped = true;
// Keep running until gap = 1 or none elements were 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]) {
std::swap(a[i], a[i + gap]);
swapped = true;
}
}
}
}
int main() {
std::cin >> n;
for (int i = 1; i <= n; ++i) std::cin >> a[i];
CombSort(a, 1, n);
for (int i = 1; i <= n; ++i) std::cout << a[i] << ' ';
return 0;
}

59
sorting/combsort.cpp
View File

@@ -1,59 +0,0 @@
//Kind of better version of Bubble sort.
//While Bubble sort is comparering adjacent value, Combsort is using gap larger than 1
//Best case: O(n)
//Worst case: O(n ^ 2)
#include <iostream>
using namespace std;
int a[100005];
int n;
int FindNextGap(int x)
{
x = (x * 10) / 13;
return max(1, x);
}
void CombSort(int a[], int l, int r)
{
//Init gap
int gap = n;
//Initialize swapped as true to make sure that loop runs
bool swapped = true;
//Keep running until gap = 1 or none elements were 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])
{
swap(a[i], a[i + gap]);
swapped = true;
}
}
}
}
int main()
{
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> a[i];
CombSort(a, 1, n);
for (int i = 1; i <= n; ++i)
cout << a[i] << ' ';
return 0;
}

57
sorting/counting_sort.cpp Normal file
View File

@@ -0,0 +1,57 @@
#include <iostream>
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 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;
}
void Print(int Arr[], int N) {
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 *Count = new int[max - min + 1];
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 = N - 1; i >= 0; i--) {
Sorted_Arr[Count[Arr[i] - min] - 1] = Arr[i];
Count[Arr[i] - min]--;
}
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;
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;
}

22
sorting/CountingSortString.cpp → sorting/counting_sort_string.cpp
View File

@@ -3,35 +3,27 @@
using namespace std;
void countSort(string arr)
{
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)
{
for (i = 0; arr[i]; ++i) {
output[count[arr[i]] - 1] = arr[i];
--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;
}
int main()
{
int main() {
string arr;
cin >> arr;

374
sorting/doxy.txt
View File

@@ -1,374 +0,0 @@
# Doxyfile 1.8.13
#This configuration file has been generated from Doxygen template.
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
DOXYFILE_ENCODING = UTF-8
PROJECT_NAME = "My Project"
PROJECT_NUMBER =
PROJECT_BRIEF =
PROJECT_LOGO =
OUTPUT_DIRECTORY =
CREATE_SUBDIRS = NO
ALLOW_UNICODE_NAMES = NO
OUTPUT_LANGUAGE = English
BRIEF_MEMBER_DESC = YES
REPEAT_BRIEF = YES
ABBREVIATE_BRIEF = "The $name class" \
"The $name widget" \
"The $name file" \
is \
provides \
specifies \
contains \
represents \
a \
an \
the
ALWAYS_DETAILED_SEC = NO
INLINE_INHERITED_MEMB = NO
FULL_PATH_NAMES = YES
STRIP_FROM_PATH =
STRIP_FROM_INC_PATH =
SHORT_NAMES = NO
JAVADOC_AUTOBRIEF = NO
QT_AUTOBRIEF = NO
MULTILINE_CPP_IS_BRIEF = NO
INHERIT_DOCS = YES
SEPARATE_MEMBER_PAGES = NO
TAB_SIZE = 4
ALIASES =
TCL_SUBST =
OPTIMIZE_OUTPUT_FOR_C = NO
OPTIMIZE_OUTPUT_JAVA = NO
OPTIMIZE_FOR_FORTRAN = NO
OPTIMIZE_OUTPUT_VHDL = NO
EXTENSION_MAPPING =
MARKDOWN_SUPPORT = YES
TOC_INCLUDE_HEADINGS = 0
AUTOLINK_SUPPORT = YES
BUILTIN_STL_SUPPORT = NO
CPP_CLI_SUPPORT = NO
SIP_SUPPORT = NO
IDL_PROPERTY_SUPPORT = YES
DISTRIBUTE_GROUP_DOC = NO
GROUP_NESTED_COMPOUNDS = NO
SUBGROUPING = YES
INLINE_GROUPED_CLASSES = NO
INLINE_SIMPLE_STRUCTS = NO
TYPEDEF_HIDES_STRUCT = NO
LOOKUP_CACHE_SIZE = 0
#---------------------------------------------------------------------------
# Build related configuration options
#---------------------------------------------------------------------------
EXTRACT_ALL = NO
EXTRACT_PRIVATE = NO
EXTRACT_PACKAGE = NO
EXTRACT_STATIC = NO
EXTRACT_LOCAL_CLASSES = YES
EXTRACT_LOCAL_METHODS = NO
EXTRACT_ANON_NSPACES = NO
HIDE_UNDOC_MEMBERS = NO
HIDE_UNDOC_CLASSES = NO
HIDE_FRIEND_COMPOUNDS = NO
HIDE_IN_BODY_DOCS = NO
INTERNAL_DOCS = NO
CASE_SENSE_NAMES = YES
HIDE_SCOPE_NAMES = NO
HIDE_COMPOUND_REFERENCE= NO
SHOW_INCLUDE_FILES = YES
SHOW_GROUPED_MEMB_INC = NO
FORCE_LOCAL_INCLUDES = NO
INLINE_INFO = YES
SORT_MEMBER_DOCS = YES
SORT_BRIEF_DOCS = NO
SORT_MEMBERS_CTORS_1ST = NO
SORT_GROUP_NAMES = NO
SORT_BY_SCOPE_NAME = NO
STRICT_PROTO_MATCHING = NO
GENERATE_TODOLIST = YES
GENERATE_TESTLIST = YES
GENERATE_BUGLIST = YES
GENERATE_DEPRECATEDLIST= YES
ENABLED_SECTIONS =
MAX_INITIALIZER_LINES = 30
SHOW_USED_FILES = YES
SHOW_FILES = YES
SHOW_NAMESPACES = YES
FILE_VERSION_FILTER =
LAYOUT_FILE =
CITE_BIB_FILES =
#---------------------------------------------------------------------------
# Configuration options related to warning and progress messages
#---------------------------------------------------------------------------
QUIET = NO
WARNINGS = YES
WARN_IF_UNDOCUMENTED = YES
WARN_IF_DOC_ERROR = YES
WARN_NO_PARAMDOC = NO
WARN_AS_ERROR = NO
WARN_FORMAT = "$file:$line: $text"
WARN_LOGFILE =
#---------------------------------------------------------------------------
# Configuration options related to the input files
#---------------------------------------------------------------------------
INPUT =
INPUT_ENCODING = UTF-8
FILE_PATTERNS = *.c \
*.cc \
*.cxx \
*.cpp \
*.c++ \
*.java \
*.ii \
*.ixx \
*.ipp \
*.i++ \
*.inl \
*.idl \
*.ddl \
*.odl \
*.h \
*.hh \
*.hxx \
*.hpp \
*.h++ \
*.cs \
*.d \
*.php \
*.php4 \
*.php5 \
*.phtml \
*.inc \
*.m \
*.markdown \
*.md \
*.mm \
*.dox \
*.py \
*.pyw \
*.f90 \
*.f95 \
*.f03 \
*.f08 \
*.f \
*.for \
*.tcl \
*.vhd \
*.vhdl \
*.ucf \
*.qsf
RECURSIVE = NO
EXCLUDE =
EXCLUDE_SYMLINKS = NO
EXCLUDE_PATTERNS =
EXCLUDE_SYMBOLS =
EXAMPLE_PATH =
EXAMPLE_PATTERNS = *
EXAMPLE_RECURSIVE = NO
IMAGE_PATH =
INPUT_FILTER =
FILTER_PATTERNS =
FILTER_SOURCE_FILES = NO
FILTER_SOURCE_PATTERNS =
USE_MDFILE_AS_MAINPAGE =
#---------------------------------------------------------------------------
# Configuration options related to source browsing
#---------------------------------------------------------------------------
SOURCE_BROWSER = NO
INLINE_SOURCES = NO
STRIP_CODE_COMMENTS = YES
REFERENCED_BY_RELATION = NO
REFERENCES_RELATION = NO
REFERENCES_LINK_SOURCE = YES
SOURCE_TOOLTIPS = YES
USE_HTAGS = NO
VERBATIM_HEADERS = YES
CLANG_ASSISTED_PARSING = NO
CLANG_OPTIONS =
#---------------------------------------------------------------------------
# Configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
ALPHABETICAL_INDEX = YES
COLS_IN_ALPHA_INDEX = 5
IGNORE_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the HTML output
#---------------------------------------------------------------------------
GENERATE_HTML = YES
HTML_OUTPUT = html
HTML_FILE_EXTENSION = .html
HTML_HEADER =
HTML_FOOTER =
HTML_STYLESHEET =
HTML_EXTRA_STYLESHEET =
HTML_EXTRA_FILES =
HTML_COLORSTYLE_HUE = 220
HTML_COLORSTYLE_SAT = 100
HTML_COLORSTYLE_GAMMA = 80
HTML_TIMESTAMP = NO
HTML_DYNAMIC_SECTIONS = NO
HTML_INDEX_NUM_ENTRIES = 100
GENERATE_DOCSET = NO
DOCSET_FEEDNAME = "Doxygen generated docs"
DOCSET_BUNDLE_ID = org.doxygen.Project
DOCSET_PUBLISHER_ID = org.doxygen.Publisher
DOCSET_PUBLISHER_NAME = Publisher
GENERATE_HTMLHELP = NO
CHM_FILE =
HHC_LOCATION =
GENERATE_CHI = NO
CHM_INDEX_ENCODING =
BINARY_TOC = NO
TOC_EXPAND = NO
GENERATE_QHP = NO
QCH_FILE =
QHP_NAMESPACE = org.doxygen.Project
QHP_VIRTUAL_FOLDER = doc
QHP_CUST_FILTER_NAME =
QHP_CUST_FILTER_ATTRS =
QHP_SECT_FILTER_ATTRS =
QHG_LOCATION =
GENERATE_ECLIPSEHELP = NO
ECLIPSE_DOC_ID = org.doxygen.Project
DISABLE_INDEX = NO
GENERATE_TREEVIEW = NO
ENUM_VALUES_PER_LINE = 4
TREEVIEW_WIDTH = 250
EXT_LINKS_IN_WINDOW = NO
FORMULA_FONTSIZE = 10
FORMULA_TRANSPARENT = YES
USE_MATHJAX = NO
MATHJAX_FORMAT = HTML-CSS
MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest
MATHJAX_EXTENSIONS =
MATHJAX_CODEFILE =
SEARCHENGINE = YES
SERVER_BASED_SEARCH = NO
EXTERNAL_SEARCH = NO
SEARCHENGINE_URL =
SEARCHDATA_FILE = searchdata.xml
EXTERNAL_SEARCH_ID =
EXTRA_SEARCH_MAPPINGS =
#---------------------------------------------------------------------------
# Configuration options related to the LaTeX output
#---------------------------------------------------------------------------
GENERATE_LATEX = NO
LATEX_OUTPUT = latex
LATEX_CMD_NAME = latex
MAKEINDEX_CMD_NAME = makeindex
COMPACT_LATEX = NO
PAPER_TYPE = a4
EXTRA_PACKAGES =
LATEX_HEADER =
LATEX_FOOTER =
LATEX_EXTRA_STYLESHEET =
LATEX_EXTRA_FILES =
PDF_HYPERLINKS = YES
USE_PDFLATEX = YES
LATEX_BATCHMODE = NO
LATEX_HIDE_INDICES = NO
LATEX_SOURCE_CODE = NO
LATEX_BIB_STYLE = plain
LATEX_TIMESTAMP = NO
#---------------------------------------------------------------------------
# Configuration options related to the RTF output
#---------------------------------------------------------------------------
GENERATE_RTF = NO
RTF_OUTPUT = rtf
COMPACT_RTF = NO
RTF_HYPERLINKS = NO
RTF_STYLESHEET_FILE =
RTF_EXTENSIONS_FILE =
RTF_SOURCE_CODE = NO
#---------------------------------------------------------------------------
# Configuration options related to the man page output
#---------------------------------------------------------------------------
GENERATE_MAN = NO
MAN_OUTPUT = man
MAN_EXTENSION = .3
MAN_SUBDIR =
MAN_LINKS = NO
#---------------------------------------------------------------------------
# Configuration options related to the XML output
#---------------------------------------------------------------------------
GENERATE_XML = NO
XML_OUTPUT = xml
XML_PROGRAMLISTING = YES
#---------------------------------------------------------------------------
# Configuration options related to the DOCBOOK output
#---------------------------------------------------------------------------
GENERATE_DOCBOOK = NO
DOCBOOK_OUTPUT = docbook
DOCBOOK_PROGRAMLISTING = NO
#---------------------------------------------------------------------------
# Configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------
GENERATE_AUTOGEN_DEF = NO
#---------------------------------------------------------------------------
# Configuration options related to the Perl module output
#---------------------------------------------------------------------------
GENERATE_PERLMOD = NO
PERLMOD_LATEX = NO
PERLMOD_PRETTY = YES
PERLMOD_MAKEVAR_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------
ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = NO
EXPAND_ONLY_PREDEF = NO
SEARCH_INCLUDES = YES
INCLUDE_PATH =
INCLUDE_FILE_PATTERNS =
PREDEFINED =
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
# Configuration options related to external references
#---------------------------------------------------------------------------
TAGFILES =
GENERATE_TAGFILE =
ALLEXTERNALS = NO
EXTERNAL_GROUPS = YES
EXTERNAL_PAGES = YES
PERL_PATH = /usr/bin/perl
#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------
CLASS_DIAGRAMS = YES
MSCGEN_PATH =
DIA_PATH =
HIDE_UNDOC_RELATIONS = YES
HAVE_DOT = YES
DOT_NUM_THREADS = 0
DOT_FONTNAME = Helvetica
DOT_FONTSIZE = 10
DOT_FONTPATH =
CLASS_GRAPH = YES
COLLABORATION_GRAPH = YES
GROUP_GRAPHS = YES
UML_LOOK = NO
UML_LIMIT_NUM_FIELDS = 10
TEMPLATE_RELATIONS = NO
INCLUDE_GRAPH = YES
INCLUDED_BY_GRAPH = YES
CALL_GRAPH = NO
CALLER_GRAPH = NO
GRAPHICAL_HIERARCHY = YES
DIRECTORY_GRAPH = YES
DOT_IMAGE_FORMAT = png
INTERACTIVE_SVG = NO
DOT_PATH =
DOTFILE_DIRS =
MSCFILE_DIRS =
DIAFILE_DIRS =
PLANTUML_JAR_PATH =
PLANTUML_CFG_FILE =
PLANTUML_INCLUDE_PATH =
DOT_GRAPH_MAX_NODES = 50
MAX_DOT_GRAPH_DEPTH = 0
DOT_TRANSPARENT = NO
DOT_MULTI_TARGETS = NO
GENERATE_LEGEND = YES
DOT_CLEANUP = YES

36
sorting/insertion_sort.cpp Normal file
View File

@@ -0,0 +1,36 @@
// Insertion Sort
#include <iostream>
int main() {
int n;
std::cout << "\nEnter the length of your array : ";
std::cin >> n;
int *Array = new int[n];
std::cout << "\nEnter any " << n << " Numbers for Unsorted Array : ";
// Input
for (int i = 0; i < n; i++) {
std::cin >> Array[i];
}
// Sorting
for (int i = 1; i < n; i++) {
int temp = Array[i];
int j = i - 1;
while (j >= 0 && temp < Array[j]) {
Array[j + 1] = Array[j];
j--;
}
Array[j + 1] = temp;
}
// Output
std::cout << "\nSorted Array : ";
for (int i = 0; i < n; i++) {
std::cout << Array[i] << "\t";
}
delete[] Array;
return 0;
}

6
sorting/library_sort.cpp
View File

@@ -8,8 +8,7 @@ void librarySort(int *index, int n) {
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];
@@ -79,8 +78,7 @@ int main() {
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--

11
sorting/makefile
View File

@@ -1,11 +0,0 @@
non_recursive_merge_sort: non_recursive_merge_sort.cpp
g++ -std=c++17 -o non_recursive_merge_sort non_recursive_merge_sort.cpp
.PHONY: test
.PHONY: doc
.PHONY: clean
test: non_recursive_merge_sort
./non_recursive_merge_sort
doc: doxy.txt
doxygen doxy.txt
clean:
rm -fr non_recursive_merge_sort html

81
sorting/merge_sort.cpp Normal file
View File

@@ -0,0 +1,81 @@
#include <iostream>
void merge(int arr[], int l, int m, int r) {
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int *L = new int[n1], *R = new int[n2];
for (i = 0; i < n1; i++) L[i] = arr[l + i];
for (j = 0; j < n2; j++) R[j] = arr[m + 1 + j];
i = 0;
j = 0;
k = l;
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++;
}
delete[] L;
delete[] R;
}
void mergeSort(int arr[], int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
void show(int A[], int size) {
int i;
for (i = 0; i < size; i++) std::cout << A[i] << "\n";
}
int main() {
int size;
std::cout << "\nEnter the number of elements : ";
std::cin >> size;
int *arr = new int[size];
std::cout << "\nEnter the unsorted elements : ";
for (int i = 0; i < size; ++i) {
std::cout << "\n";
std::cin >> arr[i];
}
mergeSort(arr, 0, size);
std::cout << "Sorted array\n";
show(arr, size);
delete[] arr;
return 0;
}

65
sorting/non_recursive_merge_sort.cpp
View File

@@ -5,28 +5,31 @@
* A generic implementation of non-recursive merge sort.
*/
#include <cstddef> // for size_t
#include <iostream>
#include <utility> // for std::move & std::remove_reference_t
template<class Iterator>
namespace sorting {
template <class Iterator>
void merge(Iterator, Iterator, const Iterator, char[]);
/// bottom-up merge sort which sorts elements in a non-decreasing order
/**
* sorts elements non-recursively by breaking them into small segments, merging
* adjacent segments into larger sorted segments, then increasing the sizes of
* segments by factors of 2 and repeating the same process.
* sorts elements non-recursively by breaking them into small segments,
* merging adjacent segments into larger sorted segments, then increasing
* the sizes of segments by factors of 2 and repeating the same process.
* best-case = worst-case = O(n log(n))
* @param first points to the first element
* @param last points to 1-step past the last element
* @param n the number of elements
*/
template<class Iterator>
*/
template <class Iterator>
void non_recursive_merge_sort(const Iterator first, const Iterator last,
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
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) {
// merge adjacent segments whose number is n / (length * 2)
Iterator left(first);
@@ -49,32 +52,28 @@ void non_recursive_merge_sort(const Iterator first, const Iterator last,
* @param r points to the right part, end of left part
* @param e points to end of right part
* @param b points at the buffer
*/
template<class Iterator>
*/
template <class Iterator>
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
for (Iterator t(l); r != t; ++t)
*p++ = std::move(*t);
for (Iterator t(l); r != t; ++t) *p++ = std::move(*t);
// while neither the buffer nor the right part has been exhausted
// move the smallest element of the two back to the container
while (e != r && c != p)
*l++ = std::move(*r < *c ? *r++ : *c++);
while (e != r && c != p) *l++ = std::move(*r < *c ? *r++ : *c++);
// notice only one of the two following loops will be executed
// while the right part hasn't bee exhausted, move it back
while (e != r)
*l++ = std::move(*r++);
while (e != r) *l++ = std::move(*r++);
// while the buffer hasn't bee exhausted, move it back
while (c != p)
*l++ = std::move(*c++);
while (c != p) *l++ = std::move(*c++);
}
/// bottom-up merge sort which sorts elements in a non-decreasing order
/**
* @param first points to the first element
* @param n the number of elements
*/
template<class Iterator>
*/
template <class Iterator>
void non_recursive_merge_sort(const Iterator first, const size_t n) {
non_recursive_merge_sort(first, first + n, n);
}
@@ -82,25 +81,21 @@ void non_recursive_merge_sort(const Iterator first, const size_t n) {
/**
* @param first points to the first element
* @param last points to 1-step past the last element
*/
template<class Iterator>
*/
template <class Iterator>
void non_recursive_merge_sort(const Iterator first, const Iterator last) {
non_recursive_merge_sort(first, last, last - first);
}
/**
* @mainpage A demonstration of auto-generated documentation using Doxygen.
* Currently, it only creates output for non_recursive_merge_sort.cpp, but if
* it has proven its efficacy it can be expanded to other files.
* The configuration file is named doxy.txt and has been auto-generated too.
*/
// the remaining of this file is only for testing. It can erased to to convert
// it into a header file for later re-use.
#include <iostream>
int main(int argc, char ** argv) {
} // namespace sorting
using sorting::non_recursive_merge_sort;
int main(int argc, char** argv) {
int size;
std::cout << "Enter the number of elements : ";
std::cin >> size;
int * arr = new int[size];
int* arr = new int[size];
for (int i = 0; i < size; ++i) {
std::cout << "arr[" << i << "] = ";
std::cin >> arr[i];

55
sorting/numeric_string_sort.cpp Normal file
View File

@@ -0,0 +1,55 @@
// Using general algorithms to sort a collection of strings results in
// alphanumeric sort. If it is a numeric string, it leads to unnatural sorting
// eg, an array of strings 1,10,100,2,20,200,3,30,300
// would be sorted in that same order by using conventional sorting,
// even though we know the correct sorting order is 1,2,3,10,20,30,100,200,300
// This Programme uses a comparator to sort the array in Numerical order instead
// of Alphanumeric order
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
bool NumericSort(std::string a, std::string b) {
while (a[0] == '0') {
a.erase(a.begin());
}
while (b[0] == '0') {
b.erase(b.begin());
}
int n = a.length();
int m = b.length();
if (n == m)
return a < b;
return n < m;
}
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++) {
std::cin >> v[i];
}
sort(v.begin(), v.end());
std::cout << "Elements sorted normally \n";
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++) {
std::cout << v[i] << " ";
}
return 0;
}

53
sorting/odd_even_sort.cpp Normal file
View File

@@ -0,0 +1,53 @@
/* C++ implementation Odd Even Sort */
#include <iostream>
#include <vector>
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;
}
}
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 main() {
int size, temp;
cout << "\nEnter the number of elements : ";
cin >> size;
vector<int> arr;
cout << "\nEnter the unsorted elements : \n";
for (int i = 0; i < size; ++i) {
cin >> temp;
arr.push_back(temp);
}
oddEven(arr, size);
cout << "Sorted array\n";
show(arr, size);
return 0;
}

57
sorting/quick_sort.cpp
View File

@@ -1,8 +1,6 @@
/**
*
* copyright The Algorithms
* Author -
* Correction - ayaankhan98
* @file
* @brief Quick sort algorithm
*
* Implementation Details -
* Quick Sort is a divide and conquer algorithm. It picks and element as
@@ -26,24 +24,25 @@
#include <cstdlib>
#include <iostream>
namespace sorting {
/**
* This function takes last element as pivot, places
* the pivot element at its correct position in sorted
* array, and places all smaller (smaller than pivot)
* to left of pivot and all greater elements to right
* of pivot
* This function takes last element as pivot, places
* the pivot element at its correct position in sorted
* array, and places all smaller (smaller than pivot)
* to left of pivot and all greater elements to right
* of pivot
*
*/
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
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++) {
// If current element is smaller than or
// equal to pivot
if (arr[j] <= pivot) {
i++; // increment index of smaller element
i++; // increment index of smaller element
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
@@ -55,12 +54,12 @@ int partition(int arr[], int low, int high) {
return (i + 1);
}
/**
* The main function that implements QuickSort
* arr[] --> Array to be sorted,
* low --> Starting index,
* high --> Ending index
*/
/**
* The main function that implements QuickSort
* arr[] --> Array to be sorted,
* low --> Starting index,
* high --> Ending index
*/
void quickSort(int arr[], int low, int high) {
if (low < high) {
int p = partition(arr, low, high);
@@ -69,25 +68,35 @@ void quickSort(int arr[], int low, int high) {
}
}
} // namespace sorting
using sorting::quickSort;
// prints the array after sorting
void show(int arr[], int size) {
for (int i = 0; i < size; i++)
std::cout << arr[i] << " ";
for (int i = 0; i < size; i++) std::cout << arr[i] << " ";
std::cout << "\n";
}
// Driver program to test above functions
/** Driver program to test above functions */
int main() {
int size;
std::cout << "\nEnter the number of elements : ";
std::cin >> size;
int *arr = new int[size];
std::cout << "\nEnter the unsorted elements : ";
for (int i = 0; i < size; ++i) {
std::cin >> arr[i];
std::cout << "\n";
std::cin >> arr[i];
}
quickSort(arr, 0, size-1);
std::cout << "Sorted array : ";
quickSort(arr, 0, size);
std::cout << "Sorted array\n";
show(arr, size);
delete[] arr;
return 0;
}

58
sorting/radix_sort.cpp Normal file
View File

@@ -0,0 +1,58 @@
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
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) {
max = a[i];
}
}
int maxdigits = 0;
while (max) {
maxdigits++;
max /= 10;
}
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++) {
int t = std::pow(10, j);
if ((a[i] % (10 * t)) / t == p) {
output[k] = a[i];
k++;
}
}
}
memset(count, 0, sizeof(count));
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) {
std::cout << a[i] << " ";
}
std::cout << std::endl;
}
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);
print(a, n);
return 0;
}

33
sorting/selection_sort.cpp Normal file
View File

@@ -0,0 +1,33 @@
// Selection Sort
#include <iostream>
using namespace std;
int main() {
int Array[6];
cout << "\nEnter any 6 Numbers for Unsorted Array : ";
// 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;
}
// Output
cout << "\nSorted Array : ";
for (int i = 0; i < 6; i++) {
cout << Array[i] << "\t";
}
}

37
sorting/shell_sort.cpp Normal file
View File

@@ -0,0 +1,37 @@
#include <iostream>
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++) {
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]) {
break;
} else {
int temp = array[k + i];
array[k + i] = array[k];
array[k] = temp;
}
}
}
}
// Output
std::cout << "\nSorted array : ";
for (int i = 0; i < size; ++i) {
std::cout << array[i] << "\t";
}
delete[] array;
return 0;
}

234
sorting/shell_sort2.cpp Normal file
View File

@@ -0,0 +1,234 @@
/**
* \file
* \brief [Shell sort](https://en.wikipedia.org/wiki/Shell_sort) algorithm
* \author [Krishna Vedala](https://github.com/kvedala)
*/
#include <cassert>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <utility> // for std::swap
#include <vector>
/** pretty print array
* \param[in] arr array to print
* \param[in] LEN length of array to print
*/
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;
}
/** pretty print array
* \param[in] arr array to print
* \param[in] N length of array to print
*/
template <typename T, size_t N>
void show_data(T (&arr)[N]) {
show_data(arr, N);
}
/** \namespace sorting
* \brief Sorting algorithms
*/
namespace sorting {
/**
* Optimized algorithm - takes half the time by utilizing
* Mar
**/
template <typename 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 (j = i; j >= gap && (arr[j - gap] - tmp) > 0; j -= gap) {
arr[j] = arr[j - gap];
}
arr[j] = tmp;
}
}
}
/** function overload - when input array is of a known length array type
*/
template <typename T, size_t N>
void shell_sort(T (&arr)[N]) {
shell_sort(arr, N);
}
/** function overload - when input array is of type std::vector,
* simply send the data content and the data length to the above function.
*/
template <typename T>
void shell_sort(std::vector<T> *arr) {
shell_sort(arr->data(), arr->size());
}
} // namespace sorting
using sorting::shell_sort;
/**
* function to compare sorting using cstdlib's qsort
**/
template <typename T>
int compare(const void *a, const void *b) {
T arg1 = *static_cast<const T *>(a);
T arg2 = *static_cast<const T *>(b);
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)
}
/**
* Test implementation of shell_sort on integer arrays by comparing results
* against std::qsort.
*/
void test_int(const int NUM_DATA) {
// 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;
for (int i = 0; i < NUM_DATA; i++)
data[i] = data2[i] = (std::rand() % range) - (range >> 1);
/* sort using our implementation */
std::clock_t start = std::clock();
shell_sort(data, NUM_DATA);
std::clock_t end = std::clock();
double elapsed_time = static_cast<double>(end - start) / CLOCKS_PER_SEC;
std::cout << "Time spent sorting using shell_sort2: " << elapsed_time
<< "s\n";
/* sort using std::qsort */
start = std::clock();
std::qsort(data2, NUM_DATA, sizeof(data2[0]), compare<int>);
end = std::clock();
elapsed_time = static_cast<double>(end - start) / CLOCKS_PER_SEC;
std::cout << "Time spent sorting using std::qsort: " << elapsed_time
<< "s\n";
for (int i = 0; i < NUM_DATA; i++) {
assert(data[i] == data2[i]); // ensure that our sorting results match
// the standard results
}
delete[] data;
delete[] data2;
}
/**
* Test implementation of shell_sort on float arrays by comparing results
* against std::qsort.
*/
void test_f(const int NUM_DATA) {
// int array = new int[NUM_DATA];
float *data = new float[NUM_DATA];
float *data2 = new float[NUM_DATA];
// int array2 = new int[NUM_DATA];
int range = 1000;
for (int i = 0; i < NUM_DATA; i++) {
data[i] = data2[i] = ((std::rand() % range) - (range >> 1)) / 100.;
}
/* sort using our implementation */
std::clock_t start = std::clock();
shell_sort(data, NUM_DATA);
std::clock_t end = std::clock();
double elapsed_time = static_cast<double>(end - start) / CLOCKS_PER_SEC;
std::cout << "Time spent sorting using shell_sort2: " << elapsed_time
<< "s\n";
/* sort using std::qsort */
start = std::clock();
std::qsort(data2, NUM_DATA, sizeof(data2[0]), compare<float>);
end = std::clock();
elapsed_time = static_cast<double>(end - start) / CLOCKS_PER_SEC;
std::cout << "Time spent sorting using std::qsort: " << elapsed_time
<< "s\n";
for (int i = 0; i < NUM_DATA; i++) {
assert(data[i] == data2[i]); // ensure that our sorting results match
// the standard results
}
delete[] data;
delete[] data2;
}
/** Main function */
int main(int argc, char *argv[]) {
// initialize random number generator - once per program
std::srand(std::time(NULL));
test_int(100); // test with sorting random array of 100 values
std::cout << "Test 1 - 100 int values - passed. \n";
test_int(1000); // test with sorting random array of 1000 values
std::cout << "Test 2 - 1000 int values - passed.\n";
test_int(10000); // test with sorting random array of 10000 values
std::cout << "Test 3 - 10000 int values - passed.\n";
test_f(100); // test with sorting random array of 100 values
std::cout << "Test 1 - 100 float values - passed. \n";
test_f(1000); // test with sorting random array of 1000 values
std::cout << "Test 2 - 1000 float values - passed.\n";
test_f(10000); // test with sorting random array of 10000 values
std::cout << "Test 3 - 10000 float values - passed.\n";
int i, NUM_DATA;
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 array2 = new int[NUM_DATA];
int range = 1800;
std::srand(time(NULL));
for (i = 0; i < NUM_DATA; i++) {
// allocate random numbers in the given range
data[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); // perform sorting
std::clock_t end = std::clock();
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;
delete[] data;
return 0;
}

56
sorting/slow_sort.cpp Normal file
View File

@@ -0,0 +1,56 @@
// Returns the sorted vector after performing SlowSort
// It is a sorting algorithm that is of humorous nature and not useful.
// It's based on the principle of multiply and surrender, a tongue-in-cheek joke
// of divide and conquer. It was published in 1986 by Andrei Broder and Jorge
// Stolfi in their paper Pessimal Algorithms and Simplexity Analysis. This
// algorithm multiplies a single problem into multiple subproblems It is
// interesting because it is provably the least efficient sorting algorithm that
// can be built asymptotically, and with the restriction that such an algorithm,
// while being slow, must still all the time be working towards a result.
#include <iostream>
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]) {
temp = a[j]; // swapping a[j] & a[m]
a[j] = a[m];
a[m] = temp;
}
SlowSort(a, i, j - 1);
}
// Sample Main function
int main() {
int size;
std::cout << "\nEnter the number of elements : ";
std::cin >> size;
int *arr = new int[size];
std::cout << "\nEnter the unsorted elements : ";
for (int i = 0; i < size; ++i) {
std::cout << "\n";
std::cin >> arr[i];
}
SlowSort(arr, 0, size);
std::cout << "Sorted array\n";
for (int i = 0; i < size; ++i) {
std::cout << arr[i] << " ";
}
delete[] arr;
return 0;
}

4
sorting/swap_sort.cpp
View File

@@ -10,7 +10,7 @@ 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[n];
std::pair<int, int> *arrPos = new std::pair<int, int>[n];
for (int i = 0; i < n; i++) {
arrPos[i].first = arr[i];
arrPos[i].second = i;
@@ -53,6 +53,8 @@ int minSwaps(int arr[], int n) {
}
}
delete[] arrPos;
// Return result
return ans;
}

110
sorting/Tim Sort.cpp → sorting/tim_sort.cpp
View File

@@ -1,115 +1,103 @@
// C++ program to perform TimSort.
#include <algorithm>
#include <iostream>
using namespace std;
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++)
{
// 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++) {
int temp = arr[i];
int j = i - 1;
while (arr[j] > temp && j >= left)
{
arr[j+1] = arr[j];
while (arr[j] > temp && j >= left) {
arr[j + 1] = arr[j];
j--;
}
arr[j+1] = temp;
arr[j + 1] = temp;
}
}
// 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[len1], right[len2];
for (int i = 0; i < len1; i++)
left[i] = arr[l + i];
for (int i = 0; i < len2; i++)
right[i] = arr[m + 1 + i];
int *left = new int[len1], *right = new int[len2];
for (int i = 0; i < len1; i++) left[i] = arr[l + i];
for (int i = 0; i < len2; i++) right[i] = arr[m + 1 + i];
int i = 0;
int j = 0;
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++;
}
k++;
}
// 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++;
}
delete[] left;
delete[] right;
}
// 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, 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)
{
// 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 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) {
// 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) {
// find ending point of left sub array
// mid+1 is starting point of right sub array
int mid = left + size - 1;
int right = min((left + 2*size - 1), (n-1));
int right = std::min((left + 2 * size - 1), (n - 1));
// merge sub array arr[left.....mid] & arr[mid+1....right]
merge(arr, left, mid, right);
}
}
}
// utility function to print the Array
void printArray(int arr[], int n)
{
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
printf("\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]);
int n = sizeof(arr) / sizeof(arr[0]);
printf("Given Array is\n");
printArray(arr, n);
timSort(arr, n);
printf("After Sorting Array is\n");
printArray(arr, n);
return 0;