backup/C-Plus-Plus
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/C-Plus-Plus.git synced 2026-04-13 17:50:45 +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

92
greedy_algorithms/Knapsack.cpp
View File

@@ -1,92 +0,0 @@
#include <iostream>
using namespace std;
struct Item
{
int weight;
int profit;
};
float profitPerUnit(Item x)
{
return (float)x.profit / (float)x.weight;
}
int partition(Item arr[], int low, int high)
{
Item pivot = arr[high]; // 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 (profitPerUnit(arr[j]) <= profitPerUnit(pivot))
{
i++; // increment index of smaller element
Item temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
Item temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
return (i + 1);
}
void quickSort(Item arr[], int low, int high)
{
if (low < high)
{
int p = partition(arr, low, high);
quickSort(arr, low, p - 1);
quickSort(arr, p + 1, high);
}
}
int main()
{
cout << "\nEnter the capacity of the knapsack : ";
float capacity;
cin >> capacity;
cout << "\n Enter the number of Items : ";
int n;
cin >> n;
Item itemArray[n];
for (int i = 0; i < n; i++)
{
cout << "\nEnter the weight and profit of item " << i + 1 << " : ";
cin >> itemArray[i].weight;
cin >> itemArray[i].profit;
}
quickSort(itemArray, 0, n - 1);
// show(itemArray, n);
float maxProfit = 0;
int i = n;
while (capacity > 0 && --i >= 0)
{
if (capacity >= itemArray[i].weight)
{
maxProfit += itemArray[i].profit;
capacity -= itemArray[i].weight;
cout << "\n\t" << itemArray[i].weight << "\t" << itemArray[i].profit;
}
else
{
maxProfit += profitPerUnit(itemArray[i]) * capacity;
cout << "\n\t" << capacity << "\t" << profitPerUnit(itemArray[i]) * capacity;
capacity = 0;
break;
}
}
cout << "\nMax Profit : " << maxProfit;
return 0;
}

37
greedy_algorithms/Kruskals Minimum Spanning Tree.cpp
View File

@@ -1,37 +0,0 @@
#include <iostream>
using namespace std;
#define V 6
#define INFINITY 99999
int graph[V][V] = {
{0, 4, 1, 4, INFINITY, INFINITY},
{4, 0, 3, 8, 3, INFINITY},
{1, 3, 0, INFINITY, 1, INFINITY},
{4, 8, INFINITY, 0, 5, 7},
{INFINITY, 3, 1, 5, 0, INFINITY},
{INFINITY, INFINITY, INFINITY, 7, INFINITY, 0}};
void findMinimumEdge()
{
for (int i = 0; i < V; i++)
{
int min = INFINITY;
int minIndex = 0;
for (int j = 0; j < V; j++)
{
if (graph[i][j] != 0 && graph[i][j] < min)
{
min = graph[i][j];
minIndex = j;
}
}
cout << i << " - " << minIndex << "\t" << graph[i][minIndex] << "\n";
}
}
int main()
{
findMinimumEdge();
return 0;
}

79
greedy_algorithms/Prims Minimum Spanning Tree.cpp
View File

@@ -1,79 +0,0 @@
#include <iostream>
using namespace std;
#define V 4
#define INFINITY 99999
int graph[V][V] = {
{0, 5, 1, 2},
{5, 0, 3, 3},
{1, 3, 0, 4},
{2, 3, 4, 0}};
struct mst
{
bool visited;
int key;
int near;
};
mst MST_Array[V];
void initilize()
{
for (int i = 0; i < V; i++)
{
MST_Array[i].visited = false;
MST_Array[i].key = INFINITY; // considering INFINITY as inifinity
MST_Array[i].near = i;
}
MST_Array[0].key = 0;
}
void updateNear()
{
for (int v = 0; v < V; v++)
{
int min = INFINITY;
int minIndex = 0;
for (int i = 0; i < V; i++)
{
if (MST_Array[i].key < min && MST_Array[i].visited == false && MST_Array[i].key != INFINITY)
{
min = MST_Array[i].key;
minIndex = i;
}
}
MST_Array[minIndex].visited = true;
for (int i = 0; i < V; i++)
{
if (graph[minIndex][i] != 0 && graph[minIndex][i] < INFINITY)
{
if (graph[minIndex][i] < MST_Array[i].key)
{
MST_Array[i].key = graph[minIndex][i];
MST_Array[i].near = minIndex;
}
}
}
}
}
void show()
{
for (int i = 0; i < V; i++)
{
cout << i << " - " << MST_Array[i].near << "\t" << graph[i][MST_Array[i].near] << "\n";
}
}
int main()
{
initilize();
updateNear();
show();
return 0;
}

93
greedy_algorithms/Dijkstra.cpp → greedy_algorithms/dijkstra.cpp
View File

@@ -1,31 +1,25 @@
#include <iostream>
#include <limits.h>
#include <iostream>
using namespace std;
//Wrapper class for storing a graph
class Graph
{
public:
// Wrapper class for storing a graph
class Graph {
public:
int vertexNum;
int **edges;
//Constructs a graph with V vertices and E edges
Graph(const int V)
{
// Constructs a graph with V vertices and E edges
Graph(const int V) {
// initializes the array edges.
this->edges = new int *[V];
for (int i = 0; i < V; i++)
{
for (int i = 0; i < V; i++) {
edges[i] = new int[V];
}
// fills the array with zeros.
for (int i = 0; i < V; i++)
{
for (int j = 0; j < V; j++)
{
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
edges[i][j] = 0;
}
}
@@ -33,20 +27,16 @@ public:
this->vertexNum = V;
}
//Adds the given edge to the graph
void addEdge(int src, int dst, int weight)
{
// Adds the given edge to the graph
void addEdge(int src, int dst, int weight) {
this->edges[src][dst] = weight;
}
};
//Utility function to find minimum distance vertex in mdist
int minDistance(int mdist[], bool vset[], int V)
{
// Utility function to find minimum distance vertex in mdist
int minDistance(int mdist[], bool vset[], int V) {
int minVal = INT_MAX, minInd = 0;
for (int i = 0; i < V; i++)
{
if (!vset[i] && (mdist[i] < minVal))
{
for (int i = 0; i < V; i++) {
if (!vset[i] && (mdist[i] < minVal)) {
minVal = mdist[i];
minInd = i;
}
@@ -55,12 +45,10 @@ int minDistance(int mdist[], bool vset[], int V)
return minInd;
}
//Utility function to print distances
void print(int dist[], int V)
{
// Utility function to print distances
void print(int dist[], int V) {
cout << "\nVertex Distance" << endl;
for (int i = 0; i < V; i++)
{
for (int i = 0; i < V; i++) {
if (dist[i] < INT_MAX)
cout << i << "\t" << dist[i] << endl;
else
@@ -68,36 +56,32 @@ void print(int dist[], int V)
}
}
//The main function that finds the shortest path from given source
//to all other vertices using Dijkstra's Algorithm.It doesn't work on negative
//weights
void Dijkstra(Graph graph, int src)
{
// The main function that finds the shortest path from given source
// to all other vertices using Dijkstra's Algorithm.It doesn't work on negative
// weights
void Dijkstra(Graph graph, int src) {
int V = graph.vertexNum;
int mdist[V]; //Stores updated distances to vertex
bool vset[V]; // vset[i] is true if the vertex i included
int mdist[V]; // Stores updated distances to vertex
bool vset[V]; // vset[i] is true if the vertex i included
// in the shortest path tree
//Initialise mdist and vset. Set distance of source as zero
for (int i = 0; i < V; i++)
{
// Initialise mdist and vset. Set distance of source as zero
for (int i = 0; i < V; i++) {
mdist[i] = INT_MAX;
vset[i] = false;
}
mdist[src] = 0;
//iterate to find shortest path
for (int count = 0; count < V - 1; count++)
{
// iterate to find shortest path
for (int count = 0; count < V - 1; count++) {
int u = minDistance(mdist, vset, V);
vset[u] = true;
for (int v = 0; v < V; v++)
{
if (!vset[v] && graph.edges[u][v] && mdist[u] + graph.edges[u][v] < mdist[v])
{
for (int v = 0; v < V; v++) {
if (!vset[v] && graph.edges[u][v] &&
mdist[u] + graph.edges[u][v] < mdist[v]) {
mdist[v] = mdist[u] + graph.edges[u][v];
}
}
@@ -106,9 +90,8 @@ void Dijkstra(Graph graph, int src)
print(mdist, V);
}
//Driver Function
int main()
{
// Driver Function
int main() {
int V, E, gsrc;
int src, dst, weight;
cout << "Enter number of vertices: ";
@@ -116,8 +99,7 @@ int main()
cout << "Enter number of edges: ";
cin >> E;
Graph G(V);
for (int i = 0; i < E; i++)
{
for (int i = 0; i < E; i++) {
cout << "\nEdge " << i + 1 << "\nEnter source: ";
cin >> src;
cout << "Enter destination: ";
@@ -126,12 +108,9 @@ int main()
cin >> weight;
// makes sure source and destionation are in the proper bounds.
if (src >= 0 && src < V && dst >= 0 && dst < V)
{
if (src >= 0 && src < V && dst >= 0 && dst < V) {
G.addEdge(src, dst, weight);
}
else
{
} else {
cout << "source and/or destination out of bounds" << endl;
i--;
continue;

207
greedy_algorithms/huffman.cpp
View File

@@ -1,109 +1,100 @@
// C++ program for Huffman Coding
// C++ program for Huffman Coding
#include <iostream>
#include <queue>
using namespace std;
// A Huffman tree node
struct MinHeapNode {
// One of the input characters
char data;
// Frequency of the character
unsigned freq;
// Left and right child
MinHeapNode *left, *right;
MinHeapNode(char data, unsigned freq)
{
left = right = NULL;
this->data = data;
this->freq = freq;
}
};
// For comparison of
// two heap nodes (needed in min heap)
struct compare {
bool operator()(MinHeapNode* l, MinHeapNode* r)
{
return (l->freq > r->freq);
}
};
// Prints huffman codes from
// the root of Huffman Tree.
void printCodes(struct MinHeapNode* root, string str)
{
if (!root)
return;
if (root->data != '$')
cout << root->data << ": " << str << "\n";
printCodes(root->left, str + "0");
printCodes(root->right, str + "1");
}
// The main function that builds a Huffman Tree and
// print codes by traversing the built Huffman Tree
void HuffmanCodes(char data[], int freq[], int size)
{
struct MinHeapNode *left, *right, *top;
// Create a min heap & inserts all characters of data[]
priority_queue<MinHeapNode*, vector<MinHeapNode*>, compare> minHeap;
for (int i = 0; i < size; ++i)
minHeap.push(new MinHeapNode(data[i], freq[i]));
// Iterate while size of heap doesn't become 1
while (minHeap.size() != 1) {
// Extract the two minimum
// freq items from min heap
left = minHeap.top();
minHeap.pop();
right = minHeap.top();
minHeap.pop();
// Create a new internal node with
// frequency equal to the sum of the
// two nodes frequencies. Make the
// two extracted node as left and right children
// of this new node. Add this node
// to the min heap '$' is a special value
// for internal nodes, not used
top = new MinHeapNode('$', left->freq + right->freq);
top->left = left;
top->right = right;
minHeap.push(top);
}
// Print Huffman codes using
// the Huffman tree built above
printCodes(minHeap.top(), "");
}
// Driver program to test above functions
int main()
{
char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' };
int freq[] = { 5, 9, 12, 13, 16, 45 };
int size = sizeof(arr) / sizeof(arr[0]);
HuffmanCodes(arr, freq, size);
return 0;
}
#include <queue>
using namespace std;
// A Huffman tree node
struct MinHeapNode {
// One of the input characters
char data;
// Frequency of the character
unsigned freq;
// Left and right child
MinHeapNode *left, *right;
MinHeapNode(char data, unsigned freq)
{
left = right = NULL;
this->data = data;
this->freq = freq;
}
};
// For comparison of
// two heap nodes (needed in min heap)
struct compare {
bool operator()(MinHeapNode* l, MinHeapNode* r)
{
return (l->freq > r->freq);
}
};
// Prints huffman codes from
// the root of Huffman Tree.
void printCodes(struct MinHeapNode* root, string str) {
if (!root)
return;
if (root->data != '$')
cout << root->data << ": " << str << "\n";
printCodes(root->left, str + "0");
printCodes(root->right, str + "1");
}
// The main function that builds a Huffman Tree and
// print codes by traversing the built Huffman Tree
void HuffmanCodes(char data[], int freq[], int size) {
struct MinHeapNode *left, *right, *top;
// Create a min heap & inserts all characters of data[]
priority_queue<MinHeapNode*, vector<MinHeapNode*>, compare> minHeap;
for (int i = 0; i < size; ++i)
minHeap.push(new MinHeapNode(data[i], freq[i]));
// Iterate while size of heap doesn't become 1
while (minHeap.size() != 1) {
// Extract the two minimum
// freq items from min heap
left = minHeap.top();
minHeap.pop();
right = minHeap.top();
minHeap.pop();
// Create a new internal node with
// frequency equal to the sum of the
// two nodes frequencies. Make the
// two extracted node as left and right children
// of this new node. Add this node
// to the min heap '$' is a special value
// for internal nodes, not used
top = new MinHeapNode('$', left->freq + right->freq);
top->left = left;
top->right = right;
minHeap.push(top);
}
// Print Huffman codes using
// the Huffman tree built above
printCodes(minHeap.top(), "");
}
// Driver program to test above functions
int main() {
char arr[] = {'a', 'b', 'c', 'd', 'e', 'f'};
int freq[] = {5, 9, 12, 13, 16, 45};
int size = sizeof(arr) / sizeof(arr[0]);
HuffmanCodes(arr, freq, size);
return 0;
}

78
greedy_algorithms/knapsack.cpp Normal file
View File

@@ -0,0 +1,78 @@
#include <iostream>
using namespace std;
struct Item {
int weight;
int profit;
};
float profitPerUnit(Item x) { return (float)x.profit / (float)x.weight; }
int partition(Item arr[], int low, int high) {
Item pivot = arr[high]; // 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 (profitPerUnit(arr[j]) <= profitPerUnit(pivot)) {
i++; // increment index of smaller element
Item temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
Item temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
return (i + 1);
}
void quickSort(Item arr[], int low, int high) {
if (low < high) {
int p = partition(arr, low, high);
quickSort(arr, low, p - 1);
quickSort(arr, p + 1, high);
}
}
int main() {
cout << "\nEnter the capacity of the knapsack : ";
float capacity;
cin >> capacity;
cout << "\n Enter the number of Items : ";
int n;
cin >> n;
Item itemArray[n];
for (int i = 0; i < n; i++) {
cout << "\nEnter the weight and profit of item " << i + 1 << " : ";
cin >> itemArray[i].weight;
cin >> itemArray[i].profit;
}
quickSort(itemArray, 0, n - 1);
// show(itemArray, n);
float maxProfit = 0;
int i = n;
while (capacity > 0 && --i >= 0) {
if (capacity >= itemArray[i].weight) {
maxProfit += itemArray[i].profit;
capacity -= itemArray[i].weight;
cout << "\n\t" << itemArray[i].weight << "\t"
<< itemArray[i].profit;
} else {
maxProfit += profitPerUnit(itemArray[i]) * capacity;
cout << "\n\t" << capacity << "\t"
<< profitPerUnit(itemArray[i]) * capacity;
capacity = 0;
break;
}
}
cout << "\nMax Profit : " << maxProfit;
return 0;
}

31
greedy_algorithms/kruskals_minimum_spanning_tree.cpp Normal file
View File

@@ -0,0 +1,31 @@
#include <iostream>
using namespace std;
#define V 6
#define INFINITY 99999
int graph[V][V] = {{0, 4, 1, 4, INFINITY, INFINITY},
{4, 0, 3, 8, 3, INFINITY},
{1, 3, 0, INFINITY, 1, INFINITY},
{4, 8, INFINITY, 0, 5, 7},
{INFINITY, 3, 1, 5, 0, INFINITY},
{INFINITY, INFINITY, INFINITY, 7, INFINITY, 0}};
void findMinimumEdge() {
for (int i = 0; i < V; i++) {
int min = INFINITY;
int minIndex = 0;
for (int j = 0; j < V; j++) {
if (graph[i][j] != 0 && graph[i][j] < min) {
min = graph[i][j];
minIndex = j;
}
}
cout << i << " - " << minIndex << "\t" << graph[i][minIndex] << "\n";
}
}
int main() {
findMinimumEdge();
return 0;
}

64
greedy_algorithms/prims_minimum_spanning_tree.cpp Normal file
View File

@@ -0,0 +1,64 @@
#include <iostream>
using namespace std;
#define V 4
#define INFINITY 99999
int graph[V][V] = {{0, 5, 1, 2}, {5, 0, 3, 3}, {1, 3, 0, 4}, {2, 3, 4, 0}};
struct mst {
bool visited;
int key;
int near;
};
mst MST_Array[V];
void initilize() {
for (int i = 0; i < V; i++) {
MST_Array[i].visited = false;
MST_Array[i].key = INFINITY; // considering INFINITY as inifinity
MST_Array[i].near = i;
}
MST_Array[0].key = 0;
}
void updateNear() {
for (int v = 0; v < V; v++) {
int min = INFINITY;
int minIndex = 0;
for (int i = 0; i < V; i++) {
if (MST_Array[i].key < min && MST_Array[i].visited == false &&
MST_Array[i].key != INFINITY) {
min = MST_Array[i].key;
minIndex = i;
}
}
MST_Array[minIndex].visited = true;
for (int i = 0; i < V; i++) {
if (graph[minIndex][i] != 0 && graph[minIndex][i] < INFINITY) {
if (graph[minIndex][i] < MST_Array[i].key) {
MST_Array[i].key = graph[minIndex][i];
MST_Array[i].near = minIndex;
}
}
}
}
}
void show() {
for (int i = 0; i < V; i++) {
cout << i << " - " << MST_Array[i].near << "\t"
<< graph[i][MST_Array[i].near] << "\n";
}
}
int main() {
initilize();
updateNear();
show();
return 0;
}