0% found this document useful (0 votes)
71 views17 pages

NASA Document Secret

The document contains several sorting and searching algorithms implemented in C, including Bubble Sort, Insertion Sort, Selection Sort, Heap Sort, Binary Search, Min-Max Finding, Merge Sort, and a Knapsack problem using a greedy approach. Each section provides the code for the algorithm, a main function demonstrating its use, and output formatting for displaying results. Additionally, there are examples of job sequencing with deadlines using a greedy method.
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
0% found this document useful (0 votes)
71 views17 pages

NASA Document Secret

The document contains several sorting and searching algorithms implemented in C, including Bubble Sort, Insertion Sort, Selection Sort, Heap Sort, Binary Search, Min-Max Finding, Merge Sort, and a Knapsack problem using a greedy approach. Each section provides the code for the algorithm, a main function demonstrating its use, and output formatting for displaying results. Additionally, there are examples of job sequencing with deadlines using a greedy method.
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/ 17

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

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

You might also like