Scribd
Upload
6 views

Complete Algorithms and Codes

Uploaded by

eshitvagoyal
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
6 views

Complete Algorithms and Codes

Uploaded by

eshitvagoyal
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 7

Complete Algorithms and Codes

Frequency of Occurrence in Array

#include <iostream>

using namespace std;

void countFrequency(int arr[], int n) {

for (int i = 0; i < n; i++) {

if (arr[i] == -1) continue;

int count = 1;

for (int j = i + 1; j < n; j++) {

if (arr[i] == arr[j]) {

count++;

arr[j] = -1; // Mark as visited

cout << arr[i] << " occurs " << count << " times." << endl;

int main() {

int arr[] = {1, 2, 2, 3, 4, 1, 5};

int n = 7;

countFrequency(arr, n);

return 0;
}

BFS (Breadth-First Search)

#include <iostream>

using namespace std;

void BFS(int graph[10][10], int start, int n) {

int queue[10], front = 0, rear = 0;

int visited[10] = {0};

cout << "BFS Traversal: ";

queue[rear++] = start;

visited[start] = 1;

while (front < rear) {

int current = queue[front++];

cout << current << " ";

for (int i = 0; i < n; i++) {

if (graph[current][i] && !visited[i]) {

queue[rear++] = i;

visited[i] = 1;

}
cout << endl;

int main() {

int graph[10][10] = {

{0, 1, 1, 0},

{1, 0, 1, 1},

{1, 1, 0, 1},

{0, 1, 1, 0}

};

int n = 4;

BFS(graph, 0, n);

return 0;

DFS (Depth-First Search)

#include <iostream>

using namespace std;

void DFS(int graph[10][10], int visited[], int v, int n) {

cout << v << " ";

visited[v] = 1;

for (int i = 0; i < n; i++) {

if (graph[v][i] && !visited[i])

DFS(graph, visited, i, n);


}

int main() {

int graph[10][10] = {

{0, 1, 1, 0},

{1, 0, 1, 1},

{1, 1, 0, 1},

{0, 1, 1, 0}

};

int n = 4;

int visited[10] = {0};

cout << "DFS Traversal: ";

DFS(graph, visited, 0, n);

cout << endl;

return 0;

Heap Sort

#include <iostream>

using namespace std;

void heapify(int arr[], int n, int i) {

int largest = i;

int left = 2 * i + 1;
int right = 2 * i + 2;

if (left < n && arr[left] > arr[largest])

largest = left;

if (right < n && arr[right] > arr[largest])

largest = right;

if (largest != i) {

swap(arr[i], arr[largest]);

heapify(arr, n, largest);

void heapSort(int arr[], int n) {

for (int i = n / 2 - 1; i >= 0; i--)

heapify(arr, n, i);

for (int i = n - 1; i >= 0; i--) {

swap(arr[0], arr[i]);

heapify(arr, i, 0);

int main() {

int arr[] = {4, 10, 3, 5, 1};

int n = 5;
heapSort(arr, n);

cout << "Sorted array: ";

for (int i = 0; i < n; i++)

cout << arr[i] << " ";

cout << endl;

return 0;

Greedy: Fractional Knapsack

#include <iostream>

using namespace std;

void fractionalKnapsack(int weight[], int profit[], int n, int capacity) {

double ratio[10];

for (int i = 0; i < n; i++)

ratio[i] = (double)profit[i] / weight[i];

for (int i = 0; i < n - 1; i++) {

for (int j = 0; j < n - i - 1; j++) {

if (ratio[j] < ratio[j + 1]) {

swap(ratio[j], ratio[j + 1]);

swap(weight[j], weight[j + 1]);

swap(profit[j], profit[j + 1]);

}
}

double totalProfit = 0;

for (int i = 0; i < n; i++) {

if (capacity >= weight[i]) {

capacity -= weight[i];

totalProfit += profit[i];

} else {

totalProfit += profit[i] * ((double)capacity / weight[i]);

break;

cout << "Maximum Profit: " << totalProfit << endl;

int main() {

int weight[] = {10, 20, 30};

int profit[] = {60, 100, 120};

int capacity = 50;

int n = 3;

fractionalKnapsack(weight, profit, n, capacity);

return 0;

You might also like