==================================================

1. Bubble Sort
==================================================
#include <stdio.h>

void swap_bubble(int *xp, int *yp) {

int temp = *xp;
*xp = *yp;
*yp = temp;
}

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

int i, j;
for (i = 0; i < n - 1; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
swap_bubble(&arr[j], &arr[j + 1]);
}
}
}
}

void printArray_bubble(int arr[], int size) {

int i;
for (i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}

int main() {
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr) / sizeof(arr[0]);
bubbleSort(arr, n);
printf("Bubble Sorted array: \n");
printArray_bubble(arr, n);
return 0;
}

==================================================
2. Insertion Sort
==================================================
#include <stdio.h>
void insertionSort(int arr[], int n) {
int i, key, j;
for (i = 1; i < n; i++) {
key = arr[i];
j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}

void printArray_insertion(int arr[], int size) {

int i;
for (i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}

int main() {
int arr[] = {12, 11, 13, 5, 6};
int n = sizeof(arr) / sizeof(arr[0]);
insertionSort(arr, n);
printf("Insertion Sorted array: \n");
printArray_insertion(arr, n);
return 0;
}

==================================================
3. Selection Sort
==================================================
#include <stdio.h>

void swap_selection(int *xp, int *yp) {

int temp = *xp;
*xp = *yp;
*yp = temp;
}

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

int i, j, minIndex;
for (i = 0; i < n - 1; i++) {
 minIndex = i;
for (j = i + 1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
if (minIndex != i) {
swap_selection(&arr[minIndex], &arr[i]);
}
}
}

void printArray_selection(int arr[], int size) {

int i;
for (i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}

int main() {
int arr[] = {64, 25, 12, 22, 11};
int n = sizeof(arr) / sizeof(arr[0]);
selectionSort(arr, n);
printf("Selection Sorted array: \n");
printArray_selection(arr, n);
return 0;
}

==================================================
4. Heap Sort
==================================================
#include <stdio.h>

void swap_heap(int *xp, int *yp) {

int temp = *xp;
*xp = *yp;
*yp = temp;
}

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_heap(&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_heap(&arr[0], &arr[i]);
heapify(arr, i, 0);
}
}

void printArray_heap(int arr[], int size) {

int i;
for (i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}

int main() {
int arr[] = {12, 11, 13, 5, 6, 7};
int n = sizeof(arr) / sizeof(arr[0]);
heapSort(arr, n);
printf("Heap Sorted array: \n");
printArray_heap(arr, n);
return 0;
}

==================================================
5. Binary Search (Divide and Conquer)
==================================================
#include <stdio.h>
int binarySearch(int arr[], int left, int right, int x) {
if (right >= left) {
int mid = left + (right - left) / 2;
if (arr[mid] == x)
return mid;
if (arr[mid] > x)
return binarySearch(arr, left, mid - 1, x);
return binarySearch(arr, mid + 1, right, x);
}
return -1;
}

int main() {
int arr[] = {2, 3, 4, 10, 40};
int n = sizeof(arr) / sizeof(arr[0]);
int x = 10;
printf("Binary Search:\nArray: ");
for(int i=0; i<n; i++) printf("%d ", arr[i]);
printf("\nElement to search: %d\n", x);
int result = binarySearch(arr, 0, n - 1, x);
if (result == -1)
printf("Element is not present in array\n");
else
printf("Element is present at index %d\n", result);
return 0;
}

==================================================
6. Min-Max Finding (Divide and Conquer)
==================================================
#include <stdio.h>

void minMax(int arr[], int left, int right, int *min_val, int *max_val){
if(left == right){
*min_val = arr[left];
*max_val = arr[left];
return;
}
if(left == (right-1)){
if(arr[left]>arr[right]){
*min_val = arr[right];
*max_val = arr[left];
 }else {
*max_val = arr[right];
*min_val = arr[left];
}
return;
}

int mid = (left + right)/2;

int min1 , max1;

minMax(arr,left,mid,min_val,max_val);
minMax(arr,(mid+1),right,&min1,&max1);

if(*min_val > min1){

*min_val = min1;
}

if(max1 > *max_val){

*max_val = max1;
}
return;
}

int main() {
int arr[] = {22,13,-5,-8,15,60,17,31,47};
int min_result,max_result;
int n = sizeof(arr)/sizeof(arr[0]);

printf("Min-Max Finding:\nArray: ");

for(int i=0; i<n; i++) printf("%d ", arr[i]);
printf("\n");

if (n > 0) {
minMax(arr,0, n-1 ,&min_result,&max_result);
printf("Min : %d \n",min_result);
printf("Max : %d \n",max_result);
} else {
printf("Array is empty.\n");
}
return 0;
}

==================================================
7. Merge Sort (Divide and Conquer)
==================================================
#include <stdio.h>
#include <stdlib.h>

void merge(int arr[], int left, int mid, int right) {

int i, j, k;
int n1 = mid - left + 1;
int n2 = right - mid;

int L[n1], R[n2];

for (i = 0; i < n1; i++)

L[i] = arr[left + i];
for (j = 0; j < n2; j++)
R[j] = arr[mid + 1 + j];

i = 0;
j = 0;
k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}

while (i < n1) {

arr[k] = L[i];
i++;
k++;
}

while (j < n2) {

arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int left, int right) {
if (left < right) {
int mid = left + (right - left) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}

void printArray_merge(int arr[], int size) {

int i;
for (i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}

int main() {
int arr[] = {12, 11, 13, 5, 6, 7};
int arr_size = sizeof(arr) / sizeof(arr[0]);
printf("Merge Sort:\nGiven array is \n");
printArray_merge(arr, arr_size);
mergeSort(arr, 0, arr_size - 1);
printf("\nSorted array is \n");
printArray_merge(arr, arr_size);
return 0;
}

==================================================
8. Knapsack (Greedy - Image-based)
==================================================
#include <stdio.h>

void swapFloat_Knapsack_Image(float *a, float *b) {

float temp = *a;
*a = *b;
*b = temp;
}

void swapInt_Knapsack_Image(int *a, int *b) {

int temp = *a;
*a = *b;
*b = temp;
}

float knapsack_Image(int n_items, int capacity_m, int p_profits[], int w_weights[]) {

float pw_ratio[n_items];
int i, j;

for (i = 0; i < n_items; i++) {

if (w_weights[i] == 0) pw_ratio[i] = -1.0f;
else pw_ratio[i] = (float)p_profits[i] / w_weights[i];
}

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

for (j = 0; j < n_items - i - 1; j++) {
if (pw_ratio[j] < pw_ratio[j + 1]) {
swapFloat_Knapsack_Image(&pw_ratio[j], &pw_ratio[j + 1]);
swapInt_Knapsack_Image(&p_profits[j], &p_profits[j + 1]);
swapInt_Knapsack_Image(&w_weights[j], &w_weights[j + 1]);
}
}
}

float maxProfit = 0.0;

int currentWeight = 0;

printf("\nProcessing items for Knapsack:\n");

for (i = 0; i < n_items; i++) {
if (w_weights[i] == 0 && p_profits[i] > 0) {
maxProfit += p_profits[i];
printf("Item with profit %d and weight 0 - Taken fully (free profit)\n", p_profits[i]);
continue;
}
if (w_weights[i] == 0) continue;

if (currentWeight + w_weights[i] <= capacity_m) {

currentWeight += w_weights[i];
maxProfit += p_profits[i];
printf("Item with profit %d, weight %d (ratio %.2f) - Taken fully\n", p_profits[i],
w_weights[i], pw_ratio[i]);
} else {
int remaining_capacity = capacity_m - currentWeight;
if (remaining_capacity > 0) {
maxProfit += p_profits[i] * ((float)remaining_capacity / w_weights[i]);
printf("Item with profit %d, weight %d (ratio %.2f) - Taken fraction %.2f (amount
%d/%d)\n",
p_profits[i], w_weights[i], pw_ratio[i], (float)remaining_capacity / w_weights[i],
remaining_capacity, w_weights[i]);
}
break;
}
}
return maxProfit;
}

int main() {
int p_profits[] = {25, 24, 15};
int w_weights[] = {18, 15, 10};
int n_items = sizeof(p_profits) / sizeof(p_profits[0]);
int capacity_m = 20;

printf("Knapsack Problem (Image Style):\n");

printf("Number of items: %d, Knapsack Capacity: %d\n", n_items, capacity_m);
printf("Profits: ");
for(int k=0; k<n_items; k++) printf("%d ", p_profits[k]);
printf("\nWeights: ");
for(int k=0; k<n_items; k++) printf("%d ", w_weights[k]);
printf("\n");

float resultProfit = knapsack_Image(n_items, capacity_m, p_profits, w_weights);

printf("\nMax Profit: %.2f\n", resultProfit);

int p2[] = {10, 5, 15, 7, 6, 18, 3};

int w2[] = {2, 3, 5, 7, 1, 4, 1};
int n2 = sizeof(p2)/sizeof(p2[0]);
int m2 = 15;
printf("\n--- Another Knapsack Example ---\n");
printf("Number of items: %d, Knapsack Capacity: %d\n", n2, m2);
float resultProfit2 = knapsack_Image(n2, m2, p2, w2);
printf("\nMax Profit: %.2f\n", resultProfit2);
return 0;
}

==================================================
9. Job Sequencing with Deadlines (Greedy - Image-based)
==================================================
#include <stdio.h>
#include <stdlib.h>
void swap_JobSeq_Image(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}

int findMaxDeadline_JobSeq_Image(int deadlines[], int n) {

int max_d = 0;
for (int i = 0; i < n; i++) {
if (deadlines[i] > max_d) {
max_d = deadlines[i];
}
}
return max_d;
}

void jobSeq_Image(int n_jobs, int profits[], int deadlines[], int original_job_ids_param[], int
result_job_slots[], int max_deadline_m) {
int job_indices_internal[n_jobs];
int temp_profits[n_jobs];
int temp_deadlines[n_jobs];
int i, j, k;

for (i = 0; i < n_jobs; i++) {

job_indices_internal[i] = original_job_ids_param[i];
temp_profits[i] = profits[i];
temp_deadlines[i] = deadlines[i];
}

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

for (j = 0; j < n_jobs - i - 1; j++) {
if (temp_profits[j] < temp_profits[j + 1]) {
swap_JobSeq_Image(&temp_profits[j], &temp_profits[j + 1]);
swap_JobSeq_Image(&temp_deadlines[j], &temp_deadlines[j + 1]);
swap_JobSeq_Image(&job_indices_internal[j], &job_indices_internal[j + 1]);
}
}
}

for (i = 0; i < max_deadline_m; i++) {

result_job_slots[i] = -1;
}
 int scheduled_job_count = 0;
int total_profit = 0;

printf("\nProcessing jobs for sequencing (sorted by profit desc):\n");

for (i = 0; i < n_jobs; i++) {
printf("Considering Job %d (Profit: %d, Deadline: %d)\n", job_indices_internal[i],
temp_profits[i], temp_deadlines[i]);
for (k = temp_deadlines[i] - 1; k >= 0; k--) {
if (k < max_deadline_m && result_job_slots[k] == -1) {
result_job_slots[k] = job_indices_internal[i];
total_profit += temp_profits[i];
scheduled_job_count++;
printf(" Scheduled Job %d in slot %d (deadline %d)\n", job_indices_internal[i], k,
temp_deadlines[i]);
break;
}
}
}

printf("\nScheduled Jobs (Job IDs in slots 0 to %d): ", max_deadline_m-1);

for(i = 0; i < max_deadline_m; i++) {
if(result_job_slots[i] != -1) {
printf("Slot %d: JOB%d; ", i, result_job_slots[i]);
} else {
printf("Slot %d: Empty; ", i);
}
}
printf("\nTotal Profit: %d\n", total_profit);
printf("Number of Jobs Scheduled: %d\n", scheduled_job_count);
}

int main() {
int profits_arr[] = {20, 15, 10, 5, 1};
int deadlines_arr[] = {2, 2, 1, 3, 3};
int n = sizeof(profits_arr) / sizeof(profits_arr[0]);
int job_ids[n];
for(int i=0; i<n; i++) job_ids[i] = i+1;

printf("Job Sequencing (Image Style):\n");

printf("Number of jobs: %d\n", n);
printf("Original Jobs:\n");
for(int i=0; i<n; i++) {
 printf(" Job %d: Profit=%d, Deadline=%d\n", job_ids[i], profits_arr[i], deadlines_arr[i]);
}

int max_d = findMaxDeadline_JobSeq_Image(deadlines_arr, n);

if (max_d == 0 && n > 0) max_d = 1;
else if (n==0) max_d = 0;

int result_jobs[max_d > 0 ? max_d : 1];

if (n > 0) {
jobSeq_Image(n, profits_arr, deadlines_arr, job_ids, result_jobs, max_d);
} else {
printf("No jobs to schedule.\n");
}

printf("\n--- Job Sequencing Example (from image description) ---\n");

int profits2[] = {3, 5, 20, 18, 1, 6, 30};
int deadlines2[] = {1, 3, 4, 3, 2, 1, 2};
int n2 = 7;
int job_ids2[n2];
for(int i=0; i<n2; i++) job_ids2[i] = i+1;

printf("Number of jobs: %d\n", n2);

printf("Original Jobs:\n");
for(int i=0; i<n2; i++) {
printf(" Job %d: Profit=%d, Deadline=%d\n", job_ids2[i], profits2[i], deadlines2[i]);
}

int max_d2 = findMaxDeadline_JobSeq_Image(deadlines2, n2);

int result_jobs2[max_d2 > 0 ? max_d2 : 1];
jobSeq_Image(n2, profits2, deadlines2, job_ids2, result_jobs2, max_d2);

return 0;
}

==================================================
10. Multistage Graph (Dynamic Programming - Image-based)
==================================================
#include <stdio.h>
#include <limits.h>

#define MAX_VERTICES_MS 100

int graph_ms[MAX_VERTICES_MS][MAX_VERTICES_MS];
int cost_ms[MAX_VERTICES_MS];
int path_ms[MAX_VERTICES_MS];

void shortestPathMultistageGraph_Image(int num_vertices) {

if (num_vertices <= 0 || num_vertices > MAX_VERTICES_MS) {
printf("Invalid number of vertices.\n");
return;
}
int start_node = 0;
int destination_node = num_vertices - 1;
int v, next_v;

cost_ms[destination_node] = 0;
path_ms[destination_node] = destination_node;

for (v = destination_node - 1; v >= start_node; v--) {

cost_ms[v] = INT_MAX;
path_ms[v] = -1;

for (next_v = v + 1; next_v < num_vertices; next_v++) {

if (graph_ms[v][next_v] != 0 && graph_ms[v][next_v] != INT_MAX && cost_ms[next_v] !=
INT_MAX) {
if (graph_ms[v][next_v] + cost_ms[next_v] < cost_ms[v]) {
cost_ms[v] = graph_ms[v][next_v] + cost_ms[next_v];
path_ms[v] = next_v;
}
}
}
}

if (cost_ms[start_node] == INT_MAX) {
printf("No path from start node %d to destination node %d.\n", start_node,
destination_node);
return;
}

printf("Shortest Path from %d to %d: ", start_node, destination_node);

int current_node = start_node;
int path_count = 0;
while (current_node != destination_node && path_count < num_vertices) {
printf("%d -- ", current_node);
 if (path_ms[current_node] == -1 || (path_ms[current_node] == current_node &&
current_node != destination_node) ) {
printf("\nError in path reconstruction or no valid next step from %d.\n", current_node);
return;
}
current_node = path_ms[current_node];
path_count++;
}
if(current_node == destination_node) {
printf("%d\n", destination_node);
printf("Minimum Cost: %d\n", cost_ms[start_node]);
} else {
printf("\nCould not reach destination node. Path reconstruction failed. Last node: %d\n",
current_node);
}
}

int main() {
printf("Multistage Graph (Image Style):\n");
int vertices1 = 6;
int exampleGraph_ms1[6][6] = {
{0, 2, 3, 0, 0, 0},
{0, 0, 0, 2, 3, 0},
{0, 0, 0, 3, 1, 0},
{0, 0, 0, 0, 0, 2},
{0, 0, 0, 0, 0, 3},
{0, 0, 0, 0, 0, 0}
};

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

for (int j = 0; j < vertices1; j++) {
graph_ms[i][j] = exampleGraph_ms1[i][j];
}
}
shortestPathMultistageGraph_Image(vertices1);

printf("\n--- Multistage Graph Example (8 vertices) ---\n");

int vertices2 = 8;
int exampleGraph_ms2[MAX_VERTICES_MS][MAX_VERTICES_MS] = {
{0, 1, 2, 5, 0, 0, 0, 0},
{0, 0, 0, 0, 4, 11,0, 0},
{0, 0, 0, 0, 9, 5, 16,0},
{0, 0, 0, 0, 0, 0, 2, 0},
 {0, 0, 0, 0, 0, 0, 0, 18},
{0, 0, 0, 0, 0, 0, 0, 13},
{0, 0, 0, 0, 0, 0, 0, 2},
{0, 0, 0, 0, 0, 0, 0, 0}
};
for (int i = 0; i < vertices2; i++) {
for (int j = 0; j < vertices2; j++) {
graph_ms[i][j] = exampleGraph_ms2[i][j];
if (i >= vertices2 || j >= vertices2) graph_ms[i][j] = 0;
}
}
shortestPathMultistageGraph_Image(vertices2);
return 0;
}

==================================================
11. N-Queen (Backtracking - Image-based 4-Queen)
==================================================
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define N_VALUE 4

int board_nq[N_VALUE];
int solution_count_nq = 0;

void printBoard_NQueen_Image() {
solution_count_nq++;
printf("Solution %d:\n", solution_count_nq);
for (int i = 0; i < N_VALUE; i++) {
for (int j = 0; j < N_VALUE; j++) {
if (board_nq[i] == j) {
printf("Q ");
} else {
printf(". ");
}
}
printf("\n");
}
printf("\n");
}
int isSafe_NQueen_Image(int row, int col) {
for (int i = 0; i < row; i++) {
if (board_nq[i] == col) {
return 0;
}
if (abs(board_nq[i] - col) == abs(i - row)) {
return 0;
}
}
return 1;
}

void solveNQueens_Image(int row) {

if (row == N_VALUE) {
printBoard_NQueen_Image();
return;
}

for (int col = 0; col < N_VALUE; col++) {

if (isSafe_NQueen_Image(row, col)) {
board_nq[row] = col;
solveNQueens_Image(row + 1);
}
}
}

int main() {
printf("N-Queen Problem for N = %d (Image Style - All Solutions):\n", N_VALUE);
solveNQueens_Image(0);
if (solution_count_nq == 0) {
printf("No solutions found for N = %d.\n", N_VALUE);
}
return 0;
}