quickselect code in matlab - matlab

Question

Let us consider following pseudo code
QuickSelect(A, k)
let r be chosen uniformly at random in the range 1 to length(A)
let pivot = A[r]
let A1, A2 be new arrays
# split into a pile A1 of small elements and A2 of big elements
for i = 1 to n
if A[i] < pivot then
append A[i] to A1
else if A[i] > pivot then
append A[i] to A2
else
# do nothing
end for
if k <= length(A1):
# it's in the pile of small elements
return QuickSelect(A1, k)
else if k > length(A) - length(A2)
# it's in the pile of big elements
return QuickSelect(A2, k - (length(A) - length(A2))
else
# it's equal to the pivot
return pivot
I have wrote following code in matlab
function []=Quickselect(A,k);
% A-unsorted array
%k-we want to return kth largest element
% let r be chosen uniformly at random in the range 1 to length(A)
i=1; %initialize index
j=1; %initialize index
n=length(A);%length of array
r=floor(1+(n-1)*rand);%random index
pivot=A(r); % choose pivot as A(r);
A1=zeros(1,n); %create additional arrays
A2=zeros(1,n);%create additional arrays
for m=1:n
if A(m)<k
A1(i)=A(m);
i=i+1;
else if A(m)>k
A2(j)=A(m);
j=j+1;
end
end
end
if k <= numel(A1)
return Quickselect(A1,k);
else if k > (length(A) - length(A2))
return Quickselect(A2, k - (length(A) - length(A2)));
else
return pivot;
end
end
end
>> A=[2 1 4 3 6 5 7 9 8 10 11 13 21 12];
>> Quickselect(A,3)
Error: File: Quickselect.m Line: 23 Column: 10
Unexpected MATLAB expression.
I dont understand reason of error, can't i use recursive property in Matlab? thanks in advance

Answer 1

It is not a recursivity problem, it is just wrong Matlab syntax.
In Matlab, return does not force the return of a variable, but just makes the function stop and get out. If you want to return something your function should begin with:
function [outvar]=Quickselect(A,k);
And every time you have a
return pivot;
or
return Quickselect(A1,k);
You should modify it by
outvar=pivot; % or outvar=Quickselect(A1,k);
return;

Answer 2

Okay, here's what's wrong with your code. I've already commented about replacing pivot with k, but after looking at the code more closely I found a few more errors. #AnderBiguri already identified a couple of problems, and I'll mention those here as well for completeness.
function []=Quickselect(A,k);
As Ander mentioned, you need the return value. I'm going to directly use pivot. And function declarations don't need a ; after them. You're effectively creating a blank first line.
function pivot = Quickselect(A,k)
You had me confused for a second with the comments:
% A-unsorted array
%k-we want to return kth largest element
% let r be chosen uniformly at random in the range 1 to length(A)
The pseudocode you gave actually finds the kth smallest element. In the list [1, 2, 3, 4, 5], 1 would be the smallest element, 2 would be the second-smallest element, and 5 would be the fifth smallest-element.
i=1; %initialize index
j=1; %initialize index
n=length(A);%length of array
r=floor(1+(n-1)*rand);%random index
I don't know why you're not using randi here. Not actually wrong the way you're doing it, but it's much clearer, much more concise with randi.
r=randi(n); % random index
Note the % create additional arrays portion here:
pivot=A(r); % choose pivot as A(r);
A1=zeros(1,n); % create additional arrays
A2=zeros(1,n); % create additional arrays
These arrays are created with the same size as A and will always have the same size as A. This was addressed by Ander in his comment and will become very important later.
Now the for loop:
for m=1:n
if A(m)<k
Your pseudocode says:
if A[i] < pivot then
pivot is the value of the element chosen as the pivot and you're trying to split A into two lists: one with elements less than the pivot, and another with elements greater than the pivot. k is the index of an element whose value you're looking for. The pseudocode correctly uses pivot, so your code should be:
if A(m)<pivot
The same thing goes for A(m)>k. It should be A(m)>pivot. Also, in Matlab, the keyword is elseif, with no space. I'm deviating a bit from my method of commenting on individual lines as they occur, but I wanted to leave the next section uninterrupted to point out something else.
A1(i)=A(m);
i=i+1;
else if A(m)>k
A2(j)=A(m);
j=j+1;
end
end
end
See that first end? What does it end? It's better if you look at your whole code, but that last end ends the for loop. The second-to-last end ends the if-elsif. The first end is wrong and should be removed. Actually, and I'm very surprised Ander didn't mention this, but if you had properly indented your code you would never have created this bug. In fact, your entire code should be re-indented consistently for this reason as well as readability. The for loop section should look like this:
for m=1:n
if A(m)<pivot
A1(i)=A(m);
i=i+1;
elseif A(m)>pivot
A2(j)=A(m);
j=j+1;
end
end
Now it's quite obvious what blocks the ends go with and how many we need.
The next line in your code is:
if k <= numel(A1)
This is the bug I referred to above that's mentioned in Ander's comment. numel(A1) will always be equal to numel(A), because that's the way you created the array. Therefore, k will always be less than or equal to the size of the input array. (Well, it should be, but there's no explicit check for that in the pseudocode or your code, but oh well.)
So where do we get the number of elements actually added to A1? Well, we go back to that for loop where we were using i as the index of the next element to be added to A1 and j as the index of the next element to be added to A2. This means that the valid length of A1 is i-1 and the valid length of A2 is j-1. So your if statement should be:
if k <= (i-1)
Next we have:
return Quickselect(A1,k);
Ander Biguri also mentioned this one. Matlab does not return values this way; you simply set the value of the return variable that was defined in the function declaration. I used pivot, so we take the value returned from our recursive call to Quickselect and assign it to our copy of pivot. When the function ends, the value of this variable automatically becomes the return value.
Now for the parameters you're passing to the recursive call. I've already said that numel(A1) == numel(A). So if you recursively call Quickselect on A1, you're not actually reducing the size of the array. We only want to pass the valid portion of A1 and since we know that it has i-1 valid elements, we can just take the first i-1 elements, i.e. A1(1:i-1).
The correct line is:
pivot = Quickselect(A1(1:i-1),k);
Now we run into the length problem again, and you've switched from using numel to using length. Not actually wrong, as far as it goes, but bad style.
else if k > (length(A) - length(A2))
return Quickselect(A2, k - (length(A) - length(A2)));
This is always zero. The length of A minus the length of something that is the same length as A is zero. The valid length of A2 is j-1. Also, we already know the size of A, it's n from way up there at the beginning. The corrected lines:
elseif k > (n - (j-1))
pivot = Quickselect(A2(1:j-1), k - (n - (j-1)));
And so we come to the end of our code:
else
return pivot;
end
end
end
As mentioned, return doesn't set any return value, it just returns from the function. Since we're at the end of the function anyway, there's no need to return. Once again, proper indentation would show you that there is an extra end here as well. We need one for the if-elseif block, and one to end the function itself, but the third one is extraneous.
If you make these changes you will have a working quickselect function.