OpenSoure_Repos/TheAlgorithms-C-Plus-Plus
1
0
Fork 0
mirror of https://hub.njuu.cf/TheAlgorithms/C-Plus-Plus.git synced 2023-10-11 13:05:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: Reworked/updated sorting/selection_sort.cpp. (#1613)

Browse Source 
* Reworked selection_sort.cpp with fixes.

* Added Recursive implementation for tree traversing

* Fix #2

* Delete recursive_tree_traversals.cpp

* Update selection_sort.cpp

* Changes done in selection_sort_iterative.cpp

* updating DIRECTORY.md

* clang-format and clang-tidy fixes for 4681e4f7

* Update sorting/selection_sort_iterative.cpp

Co-authored-by: David Leal <halfpacho@gmail.com>

* Update sorting/selection_sort_iterative.cpp

Co-authored-by: David Leal <halfpacho@gmail.com>

* Update selection_sort_iterative.cpp

* Update sorting/selection_sort_iterative.cpp

Co-authored-by: David Leal <halfpacho@gmail.com>

* Update sorting/selection_sort_iterative.cpp

Co-authored-by: David Leal <halfpacho@gmail.com>

* clang-format and clang-tidy fixes for ca2a7c64

* Finished changes requested by ayaankhan98.

* Reworked on changes.

* clang-format and clang-tidy fixes for f79b79b7

* Corrected errors.

* Fix #2

* Fix #3

* Major Fix #3

* clang-format and clang-tidy fixes for 79341db8

* clang-format and clang-tidy fixes for 9bdf2ce4

* Update selection_sort_iterative.cpp

* clang-format and clang-tidy fixes for 9833d7a7

* clang-format and clang-tidy fixes for b7726460

Co-authored-by: David Leal <halfpacho@gmail.com>
Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Co-authored-by: Abhinn Mishra <49574460+mishraabhinn@users.noreply.github.com>
This commit is contained in:
Lajat5 2021-10-25 23:47:33 +05:30 committed by GitHub
parent 4d884b0dc7
commit b3a0070a74
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 322 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
DIRECTORY.md
View File

@ -338,7 +338,7 @@
* [Radix Sort2](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/radix_sort2.cpp)
* [Random Pivot Quick Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/random_pivot_quick_sort.cpp)
* [Recursive Bubble Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/recursive_bubble_sort.cpp)
* [Selection Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/selection_sort.cpp)
* [Selection Sort Iterative](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/selection_sort_iterative.cpp)
* [Selection Sort Recursive](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/selection_sort_recursive.cpp)
* [Shell Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/shell_sort.cpp)
* [Shell Sort2](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/shell_sort2.cpp)

21
bit_manipulation/count_of_set_bits.cpp
View File

@ -5,7 +5,8 @@
* integer.
*
* @details
* We are given an integer number. We need to calculate the number of set bits in it.
* We are given an integer number. We need to calculate the number of set bits
* in it.
*
* A binary number consists of two digits. They are 0 & 1. Digit 1 is known as
* set bit in computer terms.
@ -15,7 +16,7 @@
* @author [Prashant Thakur](https://github.com/prashant-th18)
*/
#include <cassert> /// for assert
#include <iostream> /// for IO operations
#include <iostream> /// for IO operations
/**
* @namespace bit_manipulation
* @brief Bit manipulation algorithms
@ -33,21 +34,21 @@ namespace count_of_set_bits {
* @param n is the number whose set bit will be counted
* @returns total number of set-bits in the binary representation of number `n`
*/
std::uint64_t countSetBits(std :: int64_t n) { // int64_t is preferred over int so that
// no Overflow can be there.
std::uint64_t countSetBits(
std ::int64_t n) { // int64_t is preferred over int so that
// no Overflow can be there.
int count = 0; // "count" variable is used to count number of set-bits('1') in
// binary representation of number 'n'
while (n != 0)
{
int count = 0; // "count" variable is used to count number of set-bits('1')
// in binary representation of number 'n'
while (n != 0) {
++count;
n = (n & (n - 1));
}
return count;
// Why this algorithm is better than the standard one?
// Because this algorithm runs the same number of times as the number of
// set-bits in it. Means if my number is having "3" set bits, then this while loop
// will run only "3" times!!
// set-bits in it. Means if my number is having "3" set bits, then this
// while loop will run only "3" times!!
}
} // namespace count_of_set_bits
} // namespace bit_manipulation

5
ciphers/atbash_cipher.cpp
View File

@ -22,7 +22,8 @@
*/
namespace ciphers {
/** \namespace atbash
* \brief Functions for the [Atbash Cipher](https://en.wikipedia.org/wiki/Atbash) implementation
* \brief Functions for the [Atbash
* Cipher](https://en.wikipedia.org/wiki/Atbash) implementation
*/
namespace atbash {
std::map<char, char> atbash_cipher_map = {
@ -43,7 +44,7 @@ std::map<char, char> atbash_cipher_map = {
* @param text Plaintext to be encrypted
* @returns encoded or decoded string
*/
std::string atbash_cipher(std::string text) {
std::string atbash_cipher(const std::string& text) {
std::string result;
for (char letter : text) {
result += atbash_cipher_map[letter];

2
data_structures/dsu_path_compression.cpp
View File

@ -184,7 +184,7 @@ static void test1() {
* @returns void
*/
static void test2() {
// the minimum, maximum, and size of the set
// the minimum, maximum, and size of the set
uint64_t n = 10; ///< number of items
dsu d(n + 1); ///< object of class disjoint sets
// set 1

154
data_structures/stack_using_queue.cpp
View File

@ -3,13 +3,14 @@
* @details
* Using 2 Queues inside the Stack class, we can easily implement Stack
* data structure with heavy computation in push function.
*
* References used: [StudyTonight](https://www.studytonight.com/data-structures/stack-using-queue)
*
* References used:
* [StudyTonight](https://www.studytonight.com/data-structures/stack-using-queue)
* @author [tushar2407](https://github.com/tushar2407)
*/
#include <iostream> /// for IO operations
#include <queue> /// for queue data structure
#include <cassert> /// for assert
#include <cassert> /// for assert
#include <iostream> /// for IO operations
#include <queue> /// for queue data structure
/**
* @namespace data_strcutres
@ -18,66 +19,59 @@
namespace data_structures {
/**
* @namespace stack_using_queue
* @brief Functions for the [Stack Using Queue](https://www.studytonight.com/data-structures/stack-using-queue) implementation
* @brief Functions for the [Stack Using
* Queue](https://www.studytonight.com/data-structures/stack-using-queue)
* implementation
*/
namespace stack_using_queue {
/**
* @brief Stack Class implementation for basic methods of Stack Data Structure.
*/
struct Stack {
std::queue<int64_t> main_q; ///< stores the current state of the stack
std::queue<int64_t> auxiliary_q; ///< used to carry out intermediate
///< operations to implement stack
uint32_t current_size = 0; ///< stores the current size of the stack
/**
* @brief Stack Class implementation for basic methods of Stack Data Structure.
* Returns the top most element of the stack
* @returns top element of the queue
*/
struct Stack
{
std::queue<int64_t> main_q; ///< stores the current state of the stack
std::queue<int64_t> auxiliary_q; ///< used to carry out intermediate operations to implement stack
uint32_t current_size = 0; ///< stores the current size of the stack
/**
* Returns the top most element of the stack
* @returns top element of the queue
*/
int top()
{
return main_q.front();
}
int top() { return main_q.front(); }
/**
* @brief Inserts an element to the top of the stack.
* @param val the element that will be inserted into the stack
* @returns void
*/
void push(int val)
{
auxiliary_q.push(val);
while(!main_q.empty())
{
auxiliary_q.push(main_q.front());
main_q.pop();
}
swap(main_q, auxiliary_q);
current_size++;
}
/**
* @brief Removes the topmost element from the stack
* @returns void
*/
void pop()
{
if(main_q.empty()) {
return;
}
/**
* @brief Inserts an element to the top of the stack.
* @param val the element that will be inserted into the stack
* @returns void
*/
void push(int val) {
auxiliary_q.push(val);
while (!main_q.empty()) {
auxiliary_q.push(main_q.front());
main_q.pop();
current_size--;
}
swap(main_q, auxiliary_q);
current_size++;
}
/**
* @brief Utility function to return the current size of the stack
* @returns current size of stack
*/
int size()
{
return current_size;
/**
* @brief Removes the topmost element from the stack
* @returns void
*/
void pop() {
if (main_q.empty()) {
return;
}
};
main_q.pop();
current_size--;
}
/**
* @brief Utility function to return the current size of the stack
* @returns current size of stack
*/
int size() { return current_size; }
};
} // namespace stack_using_queue
} // namespace data_structures
@ -85,30 +79,29 @@ namespace stack_using_queue {
* @brief Self-test implementations
* @returns void
*/
static void test()
{
static void test() {
data_structures::stack_using_queue::Stack s;
s.push(1); /// insert an element into the stack
s.push(2); /// insert an element into the stack
s.push(3); /// insert an element into the stack
assert(s.size()==3); /// size should be 3
assert(s.top()==3); /// topmost element in the stack should be 3
s.pop(); /// remove the topmost element from the stack
assert(s.top()==2); /// topmost element in the stack should now be 2
s.pop(); /// remove the topmost element from the stack
assert(s.top()==1);
s.push(5); /// insert an element into the stack
assert(s.top()==5); /// topmost element in the stack should now be 5
s.pop(); /// remove the topmost element from the stack
assert(s.top()==1); /// topmost element in the stack should now be 1
assert(s.size()==1); /// size should be 1
s.push(1); /// insert an element into the stack
s.push(2); /// insert an element into the stack
s.push(3); /// insert an element into the stack
assert(s.size() == 3); /// size should be 3
assert(s.top() == 3); /// topmost element in the stack should be 3
s.pop(); /// remove the topmost element from the stack
assert(s.top() == 2); /// topmost element in the stack should now be 2
s.pop(); /// remove the topmost element from the stack
assert(s.top() == 1);
s.push(5); /// insert an element into the stack
assert(s.top() == 5); /// topmost element in the stack should now be 5
s.pop(); /// remove the topmost element from the stack
assert(s.top() == 1); /// topmost element in the stack should now be 1
assert(s.size() == 1); /// size should be 1
}
/**
@ -119,8 +112,7 @@ static void test()
* declared above.
* @returns 0 on exit
*/
int main()
{
int main() {
test(); // run self-test implementations
return 0;
}

55
math/area.cpp
View File

@ -1,17 +1,19 @@
/**
* @file
* @brief Implementations for the [area](https://en.wikipedia.org/wiki/Area) of various shapes
* @details The area of a shape is the amount of 2D space it takes up.
* All shapes have a formula to get the area of any given shape.
* @brief Implementations for the [area](https://en.wikipedia.org/wiki/Area) of
* various shapes
* @details The area of a shape is the amount of 2D space it takes up.
* All shapes have a formula to get the area of any given shape.
* These implementations support multiple return types.
*
*
* @author [Focusucof](https://github.com/Focusucof)
*/
#define _USE_MATH_DEFINES
#include <cmath> /// for M_PI definition and pow()
#include <cstdint> /// for uint16_t datatype
#include <iostream> /// for IO operations
#include <cassert> /// for assert
#include <cmath> /// for M_PI definition and pow()
#include <cmath>
#include <cstdint> /// for uint16_t datatype
#include <iostream> /// for IO operations
/**
* @namespace math
@ -115,25 +117,25 @@ T cylinder_surface_area(T radius, T height) {
*/
static void test() {
// I/O variables for testing
uint16_t int_length; // 16 bit integer length input
uint16_t int_width; // 16 bit integer width input
uint16_t int_base; // 16 bit integer base input
uint16_t int_height; // 16 bit integer height input
uint16_t int_expected; // 16 bit integer expected output
uint16_t int_area; // 16 bit integer output
uint16_t int_length = 0; // 16 bit integer length input
uint16_t int_width = 0; // 16 bit integer width input
uint16_t int_base = 0; // 16 bit integer base input
uint16_t int_height = 0; // 16 bit integer height input
uint16_t int_expected = 0; // 16 bit integer expected output
uint16_t int_area = 0; // 16 bit integer output
float float_length; // float length input
float float_expected; // float expected output
float float_area; // float output
float float_length = NAN; // float length input
float float_expected = NAN; // float expected output
float float_area = NAN; // float output
double double_length; // double length input
double double_width; // double width input
double double_radius; // double radius input
double double_height; // double height input
double double_expected; // double expected output
double double_area; // double output
double double_length = NAN; // double length input
double double_width = NAN; // double width input
double double_radius = NAN; // double radius input
double double_height = NAN; // double height input
double double_expected = NAN; // double expected output
double double_area = NAN; // double output
// 1st test
// 1st test
int_length = 5;
int_expected = 25;
int_area = math::square_area(int_length);
@ -201,7 +203,9 @@ static void test() {
// 6th test
double_radius = 6;
double_expected = 113.09733552923255; // rounded down because the double datatype truncates after 14 decimal places
double_expected =
113.09733552923255; // rounded down because the double datatype
// truncates after 14 decimal places
double_area = math::circle_area(double_radius);
std::cout << "AREA OF A CIRCLE" << std::endl;
@ -239,7 +243,8 @@ static void test() {
// 9th test
double_radius = 10.0;
double_expected = 1256.6370614359172; // rounded down because the whole value gets truncated
double_expected = 1256.6370614359172; // rounded down because the whole
// value gets truncated
double_area = math::sphere_surface_area(double_radius);
std::cout << "SURFACE AREA OF A SPHERE" << std::endl;

128
math/integral_approximation2.cpp
View File

@ -1,29 +1,34 @@
/**
* @file
* @brief [Monte Carlo Integration](https://en.wikipedia.org/wiki/Monte_Carlo_integration)
* @brief [Monte Carlo
* Integration](https://en.wikipedia.org/wiki/Monte_Carlo_integration)
*
* @details
* In mathematics, Monte Carlo integration is a technique for numerical integration using random numbers.
* It is a particular Monte Carlo method that numerically computes a definite integral.
* While other algorithms usually evaluate the integrand at a regular grid, Monte Carlo randomly chooses points at which the integrand is evaluated.
* This method is particularly useful for higher-dimensional integrals.
* In mathematics, Monte Carlo integration is a technique for numerical
* integration using random numbers. It is a particular Monte Carlo method that
* numerically computes a definite integral. While other algorithms usually
* evaluate the integrand at a regular grid, Monte Carlo randomly chooses points
* at which the integrand is evaluated. This method is particularly useful for
* higher-dimensional integrals.
*
* This implementation supports arbitrary pdfs.
* These pdfs are sampled using the [Metropolis-Hastings algorithm](https://en.wikipedia.org/wiki/Metropolis–Hastings_algorithm).
* This can be swapped out by every other sampling techniques for example the inverse method.
* Metropolis-Hastings was chosen because it is the most general and can also be extended for a higher dimensional sampling space.
* These pdfs are sampled using the [Metropolis-Hastings
* algorithm](https://en.wikipedia.org/wiki/Metropolis–Hastings_algorithm). This
* can be swapped out by every other sampling techniques for example the inverse
* method. Metropolis-Hastings was chosen because it is the most general and can
* also be extended for a higher dimensional sampling space.
*
* @author [Domenic Zingsheim](https://github.com/DerAndereDomenic)
*/
#define _USE_MATH_DEFINES /// for M_PI on windows
#include <cmath> /// for math functions
#include <cstdint> /// for fixed size data types
#include <ctime> /// for time to initialize rng
#include <functional> /// for function pointers
#include <iostream> /// for std::cout
#include <random> /// for random number generation
#include <vector> /// for std::vector
#define _USE_MATH_DEFINES /// for M_PI on windows
#include <cmath> /// for math functions
#include <cstdint> /// for fixed size data types
#include <ctime> /// for time to initialize rng
#include <functional> /// for function pointers
#include <iostream> /// for std::cout
#include <random> /// for random number generation
#include <vector> /// for std::vector
/**
* @namespace math
@ -32,25 +37,34 @@
namespace math {
/**
* @namespace monte_carlo
* @brief Functions for the [Monte Carlo Integration](https://en.wikipedia.org/wiki/Monte_Carlo_integration) implementation
* @brief Functions for the [Monte Carlo
* Integration](https://en.wikipedia.org/wiki/Monte_Carlo_integration)
* implementation
*/
namespace monte_carlo {
using Function = std::function<double(double&)>; /// short-hand for std::functions used in this implementation
using Function = std::function<double(
double&)>; /// short-hand for std::functions used in this implementation
/**
* @brief Generate samples according to some pdf
* @details This function uses Metropolis-Hastings to generate random numbers. It generates a sequence of random numbers by using a markov chain.
* Therefore, we need to define a start_point and the number of samples we want to generate.
* Because the first samples generated by the markov chain may not be distributed according to the given pdf, one can specify how many samples
* @details This function uses Metropolis-Hastings to generate random numbers.
* It generates a sequence of random numbers by using a markov chain. Therefore,
* we need to define a start_point and the number of samples we want to
* generate. Because the first samples generated by the markov chain may not be
* distributed according to the given pdf, one can specify how many samples
* should be discarded before storing samples.
* @param start_point The starting point of the markov chain
* @param pdf The pdf to sample
* @param num_samples The number of samples to generate
* @param discard How many samples should be discarded at the start
* @returns A vector of size num_samples with samples distributed according to the pdf
* @returns A vector of size num_samples with samples distributed according to
* the pdf
*/
std::vector<double> generate_samples(const double& start_point, const Function& pdf, const uint32_t& num_samples, const uint32_t& discard = 100000) {
std::vector<double> generate_samples(const double& start_point,
const Function& pdf,
const uint32_t& num_samples,
const uint32_t& discard = 100000) {
std::vector<double> samples;
samples.reserve(num_samples);
@ -61,19 +75,19 @@ std::vector<double> generate_samples(const double& start_point, const Function&
std::normal_distribution<double> normal(0.0, 1.0);
generator.seed(time(nullptr));
for(uint32_t t = 0; t < num_samples + discard; ++t) {
for (uint32_t t = 0; t < num_samples + discard; ++t) {
// Generate a new proposal according to some mutation strategy.
// This is arbitrary and can be swapped.
double x_dash = normal(generator) + x_t;
double acceptance_probability = std::min(pdf(x_dash)/pdf(x_t), 1.0);
double acceptance_probability = std::min(pdf(x_dash) / pdf(x_t), 1.0);
double u = uniform(generator);
// Accept "new state" according to the acceptance_probability
if(u <= acceptance_probability) {
if (u <= acceptance_probability) {
x_t = x_dash;
}
if(t >= discard) {
if (t >= discard) {
samples.push_back(x_t);
}
}
@ -92,13 +106,17 @@ std::vector<double> generate_samples(const double& start_point, const Function&
* @param function The function to integrate
* @param pdf The pdf to sample
* @param num_samples The number of samples used to approximate the integral
* @returns The approximation of the integral according to 1/N \sum_{i}^N f(x_i) / p(x_i)
* @returns The approximation of the integral according to 1/N \sum_{i}^N f(x_i)
* / p(x_i)
*/
double integral_monte_carlo(const double& start_point, const Function& function, const Function& pdf, const uint32_t& num_samples = 1000000) {
double integral_monte_carlo(const double& start_point, const Function& function,
const Function& pdf,
const uint32_t& num_samples = 1000000) {
double integral = 0.0;
std::vector<double> samples = generate_samples(start_point, pdf, num_samples);
std::vector<double> samples =
generate_samples(start_point, pdf, num_samples);
for(double sample : samples) {
for (double sample : samples) {
integral += function(sample) / pdf(sample);
}
@ -113,8 +131,13 @@ double integral_monte_carlo(const double& start_point, const Function& function,
* @returns void
*/
static void test() {
std::cout << "Disclaimer: Because this is a randomized algorithm," << std::endl;
std::cout << "it may happen that singular samples deviate from the true result." << std::endl << std::endl;;
std::cout << "Disclaimer: Because this is a randomized algorithm,"
<< std::endl;
std::cout
<< "it may happen that singular samples deviate from the true result."
<< std::endl
<< std::endl;
;
math::monte_carlo::Function f;
math::monte_carlo::Function pdf;
@ -122,60 +145,58 @@ static void test() {
double lower_bound = 0, upper_bound = 0;
/* \int_{-2}^{2} -x^2 + 4 dx */
f = [&](double& x) {
return -x*x + 4.0;
};
f = [&](double& x) { return -x * x + 4.0; };
lower_bound = -2.0;
upper_bound = 2.0;
pdf = [&](double& x) {
if(x >= lower_bound && x <= -1.0) {
if (x >= lower_bound && x <= -1.0) {
return 0.1;
}
if(x <= upper_bound && x >= 1.0) {
if (x <= upper_bound && x >= 1.0) {
return 0.1;
}
if(x > -1.0 && x < 1.0) {
if (x > -1.0 && x < 1.0) {
return 0.4;
}
return 0.0;
};
integral = math::monte_carlo::integral_monte_carlo((upper_bound - lower_bound) / 2.0, f, pdf);
integral = math::monte_carlo::integral_monte_carlo(
(upper_bound - lower_bound) / 2.0, f, pdf);
std::cout << "This number should be close to 10.666666: " << integral << std::endl;
std::cout << "This number should be close to 10.666666: " << integral
<< std::endl;
/* \int_{0}^{1} e^x dx */
f = [&](double& x) {
return std::exp(x);
};
f = [&](double& x) { return std::exp(x); };
lower_bound = 0.0;
upper_bound = 1.0;
pdf = [&](double& x) {
if(x >= lower_bound && x <= 0.2) {
if (x >= lower_bound && x <= 0.2) {
return 0.1;
}
if(x > 0.2 && x <= 0.4) {
if (x > 0.2 && x <= 0.4) {
return 0.4;
}
if(x > 0.4 && x < upper_bound) {
if (x > 0.4 && x < upper_bound) {
return 1.5;
}
return 0.0;
};
integral = math::monte_carlo::integral_monte_carlo((upper_bound - lower_bound) / 2.0, f, pdf);
integral = math::monte_carlo::integral_monte_carlo(
(upper_bound - lower_bound) / 2.0, f, pdf);
std::cout << "This number should be close to 1.7182818: " << integral << std::endl;
std::cout << "This number should be close to 1.7182818: " << integral
<< std::endl;
/* \int_{-\infty}^{\infty} sinc(x) dx, sinc(x) = sin(pi * x) / (pi * x)
This is a difficult integral because of its infinite domain.
Therefore, it may deviate largely from the expected result.
*/
f = [&](double& x) {
return std::sin(M_PI * x) / (M_PI * x);
};
f = [&](double& x) { return std::sin(M_PI * x) / (M_PI * x); };
pdf = [&](double& x) {
return 1.0 / std::sqrt(2.0 * M_PI) * std::exp(-x * x / 2.0);
@ -183,7 +204,8 @@ static void test() {
integral = math::monte_carlo::integral_monte_carlo(0.0, f, pdf, 10000000);
std::cout << "This number should be close to 1.0: " << integral << std::endl;
std::cout << "This number should be close to 1.0: " << integral
<< std::endl;
}
/**

4
range_queries/segtree.cpp
View File

@ -144,7 +144,7 @@ void update(std::vector<int64_t> *segtree, std::vector<int64_t> *lazy,
* @returns void
*/
static void test() {
int64_t max = static_cast<int64_t>(2 * pow(2, ceil(log2(7))) - 1);
auto max = static_cast<int64_t>(2 * pow(2, ceil(log2(7))) - 1);
assert(max == 15);
std::vector<int64_t> arr{1, 2, 3, 4, 5, 6, 7}, lazy(max), segtree(max);
@ -172,7 +172,7 @@ int main() {
uint64_t n = 0;
std::cin >> n;
uint64_t max = static_cast<uint64_t>(2 * pow(2, ceil(log2(n))) - 1);
auto max = static_cast<uint64_t>(2 * pow(2, ceil(log2(n))) - 1);
std::vector<int64_t> arr(n), lazy(max), segtree(max);
int choice = 0;

33
sorting/selection_sort.cpp
View File

@ -1,33 +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";
}
}

126
sorting/selection_sort_iterative.cpp Normal file
View File

@ -0,0 +1,126 @@
/******************************************************************************
* @file
* @brief Implementation of the [Selection
* sort](https://en.wikipedia.org/wiki/Selection_sort) implementation using
* swapping
* @details
* The selection sort algorithm divides the input vector into two parts: a
* sorted subvector of items which is built up from left to right at the front
* (left) of the vector, and a subvector of the remaining unsorted items that
* occupy the rest of the vector. Initially, the sorted subvector is empty, and
* the unsorted subvector is the entire input vector. The algorithm proceeds by
* finding the smallest (or largest, depending on the sorting order) element in
* the unsorted subvector, exchanging (swapping) it with the leftmost unsorted
* element (putting it in sorted order), and moving the subvector boundaries one
* element to the right.
*
* ### Implementation
*
* SelectionSort
* The algorithm divides the input vector into two parts: the subvector of items
* already sorted, which is built up from left to right. Initially, the sorted
* subvector is empty and the unsorted subvector is the entire input vector. The
* algorithm proceeds by finding the smallest element in the unsorted subvector,
* exchanging (swapping) it with the leftmost unsorted element (putting it in
* sorted order), and moving the subvector boundaries one element to the right.
*
* @author [Lajat Manekar](https://github.com/Lazeeez)
* @author Unknown author
*******************************************************************************/
#include <algorithm> /// for std::is_sorted
#include <cassert> /// for std::assert
#include <iostream> /// for IO operations
#include <vector> /// for std::vector
/******************************************************************************
* @namespace sorting
* @brief Sorting algorithms
*******************************************************************************/
namespace sorting {
/******************************************************************************
* @brief The main function which implements Selection sort
* @param arr vector to be sorted
* @param len length of vector to be sorted
* @returns @param array resultant sorted vector
*******************************************************************************/
std::vector<uint64_t> selectionSort(const std::vector<uint64_t> &arr,
uint64_t len) {
std::vector<uint64_t> array(
arr.begin(),
arr.end()); // declare a vector in which result will be stored
for (uint64_t it = 0; it < len; ++it) {
uint64_t min = it; // set min value
for (uint64_t it2 = it + 1; it2 < len; ++it2) {
if (array[it2] < array[min]) { // check which element is smaller
min = it2; // store index of smallest element to min
}
}
if (min != it) { // swap if min does not match to i
uint64_t tmp = array[min];
array[min] = array[it];
array[it] = tmp;
}
}
return array; // return sorted vector
}
} // namespace sorting
/*******************************************************************************
* @brief Self-test implementations
* @returns void
*******************************************************************************/
static void test() {
// testcase #1
// [1, 0, 0, 1, 1, 0, 2, 1] returns [0, 0, 0, 1, 1, 1, 1, 2]
std::vector<uint64_t> vector1 = {1, 0, 0, 1, 1, 0, 2, 1};
uint64_t vector1size = vector1.size();
std::cout << "1st test... ";
std::vector<uint64_t> result_test1;
result_test1 = sorting::selectionSort(vector1, vector1size);
assert(std::is_sorted(result_test1.begin(), result_test1.end()));
std::cout << "Passed" << std::endl;
// testcase #2
// [19, 22, 540, 241, 156, 140, 12, 1] returns [1, 12, 19, 22, 140, 156,
// 241,540]
std::vector<uint64_t> vector2 = {19, 22, 540, 241, 156, 140, 12, 1};
uint64_t vector2size = vector2.size();
std::cout << "2nd test... ";
std::vector<uint64_t> result_test2;
result_test2 = sorting::selectionSort(vector2, vector2size);
assert(std::is_sorted(result_test2.begin(), result_test2.end()));
std::cout << "Passed" << std::endl;
// testcase #3
// [11, 20, 30, 41, 15, 60, 82, 15] returns [11, 15, 15, 20, 30, 41, 60, 82]
std::vector<uint64_t> vector3 = {11, 20, 30, 41, 15, 60, 82, 15};
uint64_t vector3size = vector3.size();
std::cout << "3rd test... ";
std::vector<uint64_t> result_test3;
result_test3 = sorting::selectionSort(vector3, vector3size);
assert(std::is_sorted(result_test3.begin(), result_test3.end()));
std::cout << "Passed" << std::endl;
// testcase #4
// [1, 9, 11, 546, 26, 65, 212, 14, -11] returns [-11, 1, 9, 11, 14, 26, 65,
// 212, 546]
std::vector<uint64_t> vector4 = {1, 9, 11, 546, 26, 65, 212, 14};
uint64_t vector4size = vector2.size();
std::cout << "4th test... ";
std::vector<uint64_t> result_test4;
result_test4 = sorting::selectionSort(vector4, vector4size);
assert(std::is_sorted(result_test4.begin(), result_test4.end()));
std::cout << "Passed" << std::endl;
}
/*******************************************************************************
* @brief Main function
* @returns 0 on exit
*******************************************************************************/
int main() {
test(); // run self-test implementations
return 0;
}