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

fix CPPLINT in sorting folder

Browse Source
This commit is contained in:
Krishna Vedala 2020-05-26 11:33:57 -04:00
parent 142a798520
commit 7efa52e067
No known key found for this signature in database
GPG Key ID: BA19ACF8FC8792F7
25 changed files with 372 additions and 799 deletions
Show Stats 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.
* /

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;
}

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;
}

54
sorting/bead_sort.cpp Normal file
View File

@ -0,0 +1,54 @@
// 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[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;
}

63
sorting/bitonic_sort.cpp Normal file
View File

@ -0,0 +1,63 @@
// 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;
short swap_check = 1;
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 == 1); i++) {
swap_check = 0;
for (int j = 0; j < n - 1 - i; j++) {
if (numbers[j] > numbers[j + 1]) {
swap_check = 1;
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;
}

0
sorting/bucketSort.cpp → sorting/bucket_sort.cpp
View File

101
sorting/cocktail_selection_sort.cpp Normal file
View File

@ -0,0 +1,101 @@
// 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;
}

0
sorting/combsort.cpp → sorting/comb_sort.cpp
View File

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

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

0
sorting/Insertion Sort.cpp → sorting/insertion_sort.cpp
View File

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

0
sorting/Merge Sort.cpp → sorting/merge_sort.cpp
View File

38
sorting/non_recursive_merge_sort.cpp
View File

@ -6,7 +6,7 @@
*/ */
#include <cstddef> // for size_t #include <cstddef> // for size_t
#include <utility> // for std::move & std::remove_reference_t #include <utility> // for std::move & std::remove_reference_t
template<class Iterator> template <class Iterator>
void merge(Iterator, Iterator, const Iterator, char[]); void merge(Iterator, Iterator, const Iterator, char[]);
/// bottom-up merge sort which sorts elements in a non-decreasing order /// bottom-up merge sort which sorts elements in a non-decreasing order
/** /**
@ -17,13 +17,13 @@ void merge(Iterator, Iterator, const Iterator, char[]);
* @param first points to the first element * @param first points to the first element
* @param last points to 1-step past the last element * @param last points to 1-step past the last element
* @param n the number of elements * @param n the number of elements
*/ */
template<class Iterator> template <class Iterator>
void non_recursive_merge_sort(const Iterator first, const Iterator last, void non_recursive_merge_sort(const Iterator first, const Iterator last,
const size_t n) { const size_t n) {
// create a buffer large enough to store all elements // create a buffer large enough to store all elements
// dynamically allocated to comply with cpplint // dynamically allocated to comply with cpplint
char * buffer = new char[n * sizeof(*first)]; char* buffer = new char[n * sizeof(*first)];
// buffer size can be optimized to largest power of 2 less than n elements // 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 // divide the container into equally-sized segments whose length start at 1
// and keeps increasing by factors of 2 // and keeps increasing by factors of 2
@ -49,32 +49,28 @@ void non_recursive_merge_sort(const Iterator first, const Iterator last,
* @param r points to the right part, end of left part * @param r points to the right part, end of left part
* @param e points to end of right part * @param e points to end of right part
* @param b points at the buffer * @param b points at the buffer
*/ */
template<class Iterator> template <class Iterator>
void merge(Iterator l, Iterator r, const Iterator e, char b[]) { void merge(Iterator l, Iterator r, const Iterator e, char b[]) {
// create 2 pointers to point at the buffer // create 2 pointers to point at the buffer
auto p(reinterpret_cast<std::remove_reference_t<decltype(*l)>*>(b)), c(p); auto p(reinterpret_cast<std::remove_reference_t<decltype(*l)>*>(b)), c(p);
// move the left part of the segment // move the left part of the segment
for (Iterator t(l); r != t; ++t) for (Iterator t(l); r != t; ++t) *p++ = std::move(*t);
*p++ = std::move(*t);
// while neither the buffer nor the right part has been exhausted // while neither the buffer nor the right part has been exhausted
// move the smallest element of the two back to the container // move the smallest element of the two back to the container
while (e != r && c != p) while (e != r && c != p) *l++ = std::move(*r < *c ? *r++ : *c++);
*l++ = std::move(*r < *c ? *r++ : *c++);
// notice only one of the two following loops will be executed // notice only one of the two following loops will be executed
// while the right part hasn't bee exhausted, move it back // while the right part hasn't bee exhausted, move it back
while (e != r) while (e != r) *l++ = std::move(*r++);
*l++ = std::move(*r++);
// while the buffer hasn't bee exhausted, move it back // while the buffer hasn't bee exhausted, move it back
while (c != p) while (c != p) *l++ = std::move(*c++);
*l++ = std::move(*c++);
} }
/// bottom-up merge sort which sorts elements in a non-decreasing order /// bottom-up merge sort which sorts elements in a non-decreasing order
/** /**
* @param first points to the first element * @param first points to the first element
* @param n the number of elements * @param n the number of elements
*/ */
template<class Iterator> template <class Iterator>
void non_recursive_merge_sort(const Iterator first, const size_t n) { void non_recursive_merge_sort(const Iterator first, const size_t n) {
non_recursive_merge_sort(first, first + n, n); non_recursive_merge_sort(first, first + n, n);
} }
@ -82,8 +78,8 @@ void non_recursive_merge_sort(const Iterator first, const size_t n) {
/** /**
* @param first points to the first element * @param first points to the first element
* @param last points to 1-step past the last 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) { void non_recursive_merge_sort(const Iterator first, const Iterator last) {
non_recursive_merge_sort(first, last, last - first); non_recursive_merge_sort(first, last, last - first);
} }
@ -92,15 +88,15 @@ void non_recursive_merge_sort(const Iterator first, const Iterator last) {
* Currently, it only creates output for non_recursive_merge_sort.cpp, but if * 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. * 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 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 // the remaining of this file is only for testing. It can erased to to convert
// it into a header file for later re-use. // it into a header file for later re-use.
#include <iostream> #include <iostream>
int main(int argc, char ** argv) { int main(int argc, char** argv) {
int size; int size;
std::cout << "Enter the number of elements : "; std::cout << "Enter the number of elements : ";
std::cin >> size; std::cin >> size;
int * arr = new int[size]; int* arr = new int[size];
for (int i = 0; i < size; ++i) { for (int i = 0; i < size; ++i) {
std::cout << "arr[" << i << "] = "; std::cout << "arr[" << i << "] = ";
std::cin >> arr[i]; std::cin >> arr[i];

54
sorting/numeric_string_sort.cpp Normal file
View File

@ -0,0 +1,54 @@
// 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;
}

0
sorting/OddEven Sort.cpp → sorting/odd_even_sort.cpp
View File

0
sorting/Quick Sort.cpp → sorting/quick_sort.cpp
View File

0
sorting/Radix Sort.cpp → sorting/radix_sort.cpp
View File

0
sorting/Selection Sort.cpp → sorting/selection_sort.cpp
View File

0
sorting/Shell Sort.cpp → sorting/shell_sort.cpp
View File

0
sorting/Slow Sort.cpp → sorting/slow_sort.cpp
View File

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