Design & Analysis of Algorithms Lab

(PCC-CS-407)

Bachelor of Technology (B.Tech)

in
Computer engineering(Hindi)
By

KUNAL
(21001050009)

Under the guidance of

Ms.Disha
Assistant Professor

Department of Computer Engineering

J. C. BOSE UNIVERSITY OF SCIENCE & TECHNOLOGY, YMCA

SECTOR-6 FARIDABAD
HARYANA-121006
1. Given a sorted array of n elements, possibly with
duplicates, find the number of occurrences of the target
element.

Code:
#include <stdio.h>

int count(int arr[],int n,int x)

{
int i,count =0;
i=binary(arr,10,x);
while(i>=0)
{

i f(arr[i]==x)

i--;

else

break ;

while(i<=n)

if(arr[i+1]==x)
{
i++;
count++;
}
else
break ;
}
return count;
}

int binary(int arr[],int n,int x)

{
int mid,l=0,h=n;
while(h>l)
{
mid=(h+l)/2;
if(arr[mid]==x)
return mid;
else if(arr[mid]>x)
h=mid;
else
l=mid;

}
 1. }

int main()
{
int arr[10],i,a,x;
printf("Enter the Array:");
for(i=0;i<10;i++)
scanf("%d",&arr[i]);
printf("Enter number duplicate count");
scanf("%d",&a);
x=count(arr,10,a);
printf(" here count %d",x);

return 0;
}

Output :

Time Complexity :
Best case: Ω(1)

Average case: θ(log n)

Worst case: O(n)
2. Given a 0-indexed integer array nums, find a peak
element, and return its index. If the array contains multiple
peaks, return the index to any of the peaks.
*A peak element is an element that is strictly greater than its
neighbors

Code :
#include <stdio.h>

int peak(int arr[],int n)

{
int i;
for(i=0;i<n;i++)
{
if((arr[i+1]>arr[i])&&(arr[i+1]>arr[i+2]))
return i+1;
}
return -1;
}int main()
{
int nums[10],i,n;
printf("Enter the array size\n");
scanf("%d",&n);
printf("Enter the array elements");
for(i=0;i<n;i++)
scanf("%d",&nums[i]);
i=peak(nums,n);
printf("Peak at %d",i);
return 0;
} Output :

Time Complexity :
case: Ω(1)

Average case: θ(n)

Worst case: O(n)
3. Given an array arr of positive integers sorted in a
strictly increasing order, and an integer k.
Write a function to return the kth positive integer that is
missing from this array.

Code :
#include <stdio.h>

void missing(int arr[],int n,int ki)

int i,miss[10],j,k;

for(i=0,j=0,k=0;i<n;j++,k++)

if(arr[i]==j)

i++;

k--;

else

miss[k]=j;

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

printf("%d ",miss[i]);

int main()

int nums[10],i,n,k;

printf("Enter the array size\n");

scanf("%d",&n);

printf("Enter the array elements");

for(i=0;i<n;i++)
 scanf("%d",&nums[i]);

printf("Enter the value of k");

scanf("%d",&k);

missing(nums,n,k);

return 0;

Output :

Time Complexity :
Best case: Ω(n)

Average case: θ(n)

Worst case: O(n)
4. Given an integer array nums and an integer k, return the
kth largest element in the array.
Note that it is the kth largest element in the sorted order,
not the kth distinct element. You must solve it in O(n) time
complexity

Code :
#include <stdio.h>

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

int t = *a;

*a = *b;

*b = t;

int partition(int array[], int low, int high) {

int pivot = array[high];

int i = (low - 1);

for (int j = low; j < high; j++) {

if (array[j] <= pivot) {

i++;

swap(&array[i], &array[j]);

swap(&array[i + 1], &array[high]);

return (i + 1);

int quickSort(int array[], int low, int high,int k) {

if (low < high) {

int pi = partition(array, low, high);

if(pi==k)

return pi;

else if(pi>k)

quickSort(array, low, pi - 1,k);

else
 quickSort(array, pi + 1, high,k);

}}

int main() {

int data[10],k,i,n;

printf("Enter the Size");

scanf("%d",&n);

printf("Enter Array element");

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

scanf("%d",&data[i]);

printf("Enter the k value");

scanf("%d",&k);

i= quickSort(data, 0, n - 1,n-k);

printf("Element is %d ",data[i]);

return 0;

Output :

Time Complexity :
Best case: Ω(1)
Average case: θ(n)
Worst case: O(nlogn)
5. Wiggle Sort 1:
Given an integer array nums, reorder it such that nums[0]
<=nums[1] >=nums[2]
<=nums[3]....

Code :
#include <stdio.h>

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

int t = *a;

*a = *b;

*b = t; }

int partition(int array[], int low, int high) {

int pivot = array[high];

int i = (low - 1);

for (int j = low; j < high; j++) {

if (array[j] <= pivot) {

i++;

swap(&array[i], &array[j]);

}}

swap(&array[i + 1], &array[high]);

return (i + 1);

void quickSort(int array[], int low, int high) {

if (low < high) {

int pi = partition(array, low, high);

quickSort(array, low, pi - 1);

quickSort(array, pi + 1, high);

}}

void wiggle(int arr[],int low,int high) {

int i;

quickSort(arr, low, high);

 for(i=1;i<high;i=i+2)

swap(&arr[i],&arr[i+1]);

int main() {

int data[10],i,n;

printf("Enter the Size");

scanf("%d",&n);

printf("Enter Array element");

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

scanf("%d",&data[i]);

wiggle(data, 0, n-1);

printf("Array is :\n");

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

printf("%d ",data[i]);

return 0;

Output :

Time Complexity :
Best case: Ω(nlogn)
Average case: θ(nlogn)
Worst case: O(nlogn)
6. Given the weights and values of N items, in the form of
{value, weight} put these items in a knapsack of capacity W to
get the maximum total value in the knapsack. In Fractional
Knapsack, we can break items for maximizing the total value of
the knapsack

Code :
# include<stdio.h>

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

float x[20], tp = 0;

int i, j, u

u = capacity;

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

x[i] = 0.0;

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

if (weight[i] > u)

break;

else {

x[i] = 1.0;

tp = tp + profit[i];

u = u - weight[i]; } }

if (i < n)

x[i] = u / weight[i];

tp = tp + (x[i] * profit[i]);

printf("The result vector is:- ");

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

printf("%f\t", x[i]);

printf("Maximum profit is:- %f", tp); }

int main() {

float weight[20], profit[20], capacity;

int num, i, j;

float ratio[20], temp;

printf("Enter the no. of objects:- ");

scanf("%d", &num);

printf("Enter the wts and profits of each object:- ");

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

scanf("%f %f", &weight[i], &profit[i]); }

printf("Enter the capacityacity of knapsack:- ");

scanf("%f", &capacity);

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

ratio[i] = profit[i] / weight[i]; }

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

for (j = i + 1; j < num; j++) {

if (ratio[i] < ratio[j]) {

temp = ratio[j];

ratio[j] = ratio[i];

ratio[i] = temp;

temp = weight[j];

weight[j] = weight[i];

weight[i] = temp;

temp = profit[j];

profit[j] = profit[i];

profit[i] = temp; } }}

knapsack(num, weight, profit, capacity);

return(0); }

Output :
7. Given an array of jobs where every job has a deadline
and associated profit if the job is finished before the
deadline. It is also given that every job takes a single unit
of time, so the minimum possible deadline for any job is 1.
Maximize the total profit if only one job can be scheduled at
a time .

Code :
#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

typedef struct Job {

char id;

int dead;

int profit;

} Job;

int compare(const void* a, const void* b){

Job* temp1 = (Job*)a;

Job* temp2 = (Job*)b;

return (temp2->profit - temp1->profit); }

int min(int num1, int num2){

return (num1 > num2) ? num2 : num1; }

void printJobScheduling(Job arr[], int n){

qsort(arr, n, sizeof(Job), compare);

int result[n];

bool slot[n];

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

slot[i] = false;

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

for (int j = min(n, arr[i].dead) - 1; j >= 0; j--) {

if (slot[j] == false) {

result[j] = i;

slot[j] = true;

break;} } }

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

if (slot[i])

printf("%c ", arr[result[i]].id); }

int main() {

Job arr[] = { { 'a', 2, 100 },

{ 'b', 1, 19 },

{ 'c', 2, 27 },

{ 'd', 1, 25 },

{ 'e', 3, 15 } };

int n = sizeof(arr) / sizeof(arr[0]);

printf("Following is maximum profit sequence of jobs \n");

printJobScheduling(arr, n);

return 0;

OUTPUT

Time Complexity: O(N ) 2

Space Complexity : O(N)

11:.WAP to implement 0/1 knapsack problem using greedy approach.

Code:
#include <stdio.h>

int max(int a,int b){

return (a>b)? a:b; }

int knapsack(int weight[],int profit[],int W,int n){

if(n==0 || W==0){
return 0; }
if(weight[n-1]>W){
return knapsack(weight,profit, W,n-1); }
else{
return max(profit[n-1]+knapsack(weight,profit,W-weight[n-1],n-1),knapsack(weight,profit,W,n-1)); }
}

int main() {
int n;
printf("enter the number of items\n");
scanf("%d",&n);
int W;
printf("enter the capacity of the Knapsack");
scanf("%d",&W);
int weight[n];
int profit[n];
for(int i=0;i<n;i++){
printf("enter the weight and profit for items I%d",i+1);
scanf("%d%d",&weight[i],&profit[i]); }
int ans=knapsack(weight,profit,W,n);
printf("%d",ans);
return 0; }

Time complexity :
Worst Case: 0(2^N)

Space Complexity: 0(N)

12. Given an integers array nums .find the subarray with
the largest sum and return its value.
nums={-2,1,-3,4,-1,2,1,-5,4}

Code :

#include <iostream>
#include<limits.h>
using namespace std;

int main() {
int nums[9]={-2,1,-3,4,-1,2,1,-5,4};
int maxi=INT_MIN;
for(int i=0;i<9;i++){
int sum=0;
for(int j=i;j<9;j++){
sum=sum+nums[j];
maxi=max(maxi,sum);
}
}
cout<<"maximum subarray sum is "<<maxi<<endl;
}

Time complexity:
Worst case: O(n*n)