4.2k views

Suppose we want to arrange the $n$ numbers stored in any array such that all negative values occur before all positive ones. Minimum number of exchanges required in the worst case is

1. $n-1$
2. $n$
3. $n+1$
4. None of the above
+3
Logic is similar to Quick sort partition method.
0

Chhotu by that way (partition method) it wont take minimum exchanges.

0

@Arjun sir link is not working.

Answer is (D) None of these.

We just require $n/2$ swaps in the worst case. The algorithm is as given below:

Find positive number from left side and negative number from right side and do exchange. Since, at least one of them must be less than or equal to $n/2$, there cannot be more than $n/2$ exchanges. An implementation is given below:

#include<stdio.h>
int main() {

int i, n, pi, ni, count = 0;
int a[1000];
printf("Enter size of array: ");
scanf("%d",&n);
printf("Enter numbers of array\n");
for(i=0; i<n; i++)
{
scanf("%d",&a[i]);
}
ni = n-1;
/*Making ni point to the rightmost negative number*/
while(a[ni] >= 0)
ni--;
pi = 0;
/*Making pi point to the leftmost positive number*/
while(a[pi] < 0)
pi++;
/*Looping till either negative or positive numbers exhaust*/
while(ni > pi)
{
/*Swapping a[ni] and a[pi]*/
int temp = a[pi];
a[pi] = a[ni];
a[ni] = temp;
/*Moving ni leftwards to the next negative number*/
while(a[ni] >= 0)
ni--;
/*Moving pi rightwards to the next positive number*/
while(a[pi] < 0)
pi++;
}
for(i=0; i<n; i++)
{
printf("%d ", a[i]);
}

}

edited
+1

can I use simple selection sort instead ? coz it will too lead to a minimum of n/2 exchange.

0
Is the meaning of exchange and swapping is same?
+1

yes @srestha

+2
@Arjun Sir what if the array contains negative elements on the first few and last few positions, We can not simply swap them. What to do in this case.

Let Array be,

A [10 -25 -5 -95 -22- 45 12 45 12 87 45 12 45 87 65 31 05 85 -12 -23 -45 -89 -65 -32]
Please Let me know how it can be solved in n/2.
0

Consider an array of elements: -6,-1,-5,-2,-4

Using selection sort(descending) there will be 4 exchanges(more than n/2), but no exchanges are required according to algorithm given here:

http://gatecse.in/wiki/Moving_Negative_Numbers_to_the_Beginning_of_Array

Pls verify.

0
will the answer not change if use some other algorithm?in the ques they did not mention which approach to follow
0

@srestha  i did not understand question i think.

every elements in array  -ve & +ve value ...am right?

eg ..{2,3,-2,-3}

0

no, array maynot contain any -ve number too

@Manoja

0

@srestha  ..... means array contain  one -ve number then one exchange , two -ve two exchange........n/2 -ve  n/2  exchange at max.  bcz here we don't  care about ordering means sorting here..... am i right now?

0
yes
it would be n-1 in a worst case, n is never the case because if all are -ve number then there is no exchange. But in worst case array is like 1,-1,-2,-3,-4.... so total n-1 exchange are needed.
0
Why this answer is marked wrong?? I think n-1 is worst case as compared to n/2 as n-1 will always take more time. If we look asymptotically it's O(n). Please explain I am confused
+1
I thought in the same way

+1
I figured it out the reason it's marked wrong coz question is asking minimum number of comparison. No doubt n-1 will give worst case but it won't give minimum number of comparison.
#include <stdio.h>
#include <stdlib.h>

int main()
{
int i=0,length;
printf("Enter input size\n");
scanf("%d",&length);
int *arr=(int *)malloc(sizeof(int)*length);
printf("Enter %d inputs\n",length);
for(i=0;i<length;i++){
printf("%d: ",i+1);
scanf("%d",(arr+i));
}
printf("\nInput Given: ");
for(i=0;i<length;i++){
printf("%d ",arr[i]);
}
moveAllNegativesAtLeft(arr,length);
printf("\nOutput:");
for(i=0;i<length;i++){
printf("%d ",arr[i]);
}
return 0;
}

void moveAllNegativesAtLeft(int *arr,int length){
int left=0,right=length-1,temp,nofExch=0;

// While Loop Invariants:
//1. If left>0 then, Arr[0] to Arr[left-1] are all negative numbers

//2. If right<length-1 then, Arr[right-1] to Arr[length-1] are all positive numbers.

while(left<right){
for(;left<length;left++){
if(arr[left]>=0)
break;
}
for(;right>=0;right--){
if(arr[right]<0)
break;
}
if(left<right){
temp=arr[left];
arr[left]=arr[right];
arr[right]=temp;
right--;
left++;             //After each exchange right variable decreases by one
nofExch++;    //and left variable increases by one
//and while loop runs until left<right, hence at max n/2 exchanges are possible
}

}
printf("\nTotal Number of Exchanges: %d",nofExch);
}
edited
My view : suppose we are given n numbers atored in array. We can use quick sort as in worst case it can arrange all the elements in array in( log n) time.. Run quick sort algo. On Given number and check how many times the swap() function is called in quick sort algo... So count of swap() function in quick sort algo is our minimum no of exchange required to arrange all elemnts in the given array!!! Correct me if wrong. Plzz
0
but the option is      n     n-1       n+1        n(n+1)/2

then which of the option is correct
0
quick sort best case time complexity nlogn
0
What if we apply merge sort?

1
2