MergeSort for a vector of doubles - c++

Question

I'm trying to implement a MergeSort algorithm for a vector containing double values. I have the following code with me. However, two values are being treated as zero in my input and are out of place. Can someone tell me where I've gone wrong?
P.S: I'm new to data structures so I do not know the proper use of an iterator here.
Code:
#include <iostream>
#include <vector>
void sort(std::vector<double> vec);
std::vector<double> merge(std::vector<double> left, std::vector<double> right, int len);
std::vector<double> mergeSort(std::vector<double> vec, int len);
void sort(std::vector<double> vec) {
std::vector<double> tmp = mergeSort(vec, vec.size());
for (unsigned int i = 0; i < vec.size(); i++){
vec[i] = tmp[i];
std::cout << vec[i] << " ";
}
}
std::vector<double> merge(std::vector<double> left, std::vector<double> right, int len){
std::vector<double> ret(len + len);
int left_position = 0;
int right_position = 0;
int ret_position = 0;
while (left_position < len && right_position < len){
double left_value = left[left_position];
double right_value = right[right_position];
if (left_value < right_value){
ret.insert((ret.begin() + ret_position), left_value);
//ret[ret_position] = left_value;
ret_position++;
left_position++;
}
else {
ret.insert((ret.begin() + ret_position), right_value);
ret_position++;
right_position++;
}
}
while (left_position < len){
ret.insert((ret.begin() + ret_position), left[left_position]);
ret_position++;
left_position++;
}
while (right_position < len){
ret.insert((ret.begin() + ret_position), right[right_position]);
ret_position++;
right_position++;
}
return ret;
}
std::vector<double> mergeSort(std::vector<double> vec, int len){
if (len == 1){
return vec;
}
int middle = len / 2;
std::vector<double> left(middle);
std::vector<double> right(middle);
for (int i = 0; i < middle; i++){
left.insert((left.begin() + i), vec[i]);
}
for (int j = 0; j < middle; j++){
right.insert((right.begin() + j), vec[j + middle]);
}
left = mergeSort(left, middle);
right = mergeSort(right, middle);
std::vector<double> ret = merge(left, right, middle);
return ret;
}
int main(){
std::vector<double> vec;
vec.push_back(7.04);
vec.push_back(8.04);
vec.push_back(6.04);
vec.push_back(9.04);
vec.push_back(1.04);
vec.push_back(3.04);
vec.push_back(5.04);
vec.push_back(2.04);
vec.push_back(10.04);
vec.push_back(4.04);
vec.push_back(12.04);
vec.push_back(11.04);
sort(vec);
return 0;
}
The output is: 1.04 2.04 4.04 5.04 0 7.04 8.04 0 9.04 0 12.04 0 which is weird.
(Notice that every third element in the input is being treated as 0)
Live: http://ideone.com/fHZzZf

Answer 1

I have corrected your code.
First problem was, as poined by UmNyobe, is loosing elements when computing
int middle = len / 2;
When you use constructor
std::vector<int>(size_type n);
You construct a vecror with n elements 0.0
More about vector's constructors read on here.
When you use
vec.insert(iterator pos, const value_type& val);
you are inserting a new element before position pos and increasing the size of the vector by 1.
In merge sort i recomend you to create a vector with some elements and then assign them to appropriate values.
For example as you can see in code below:
std::vector<double> ret(left.size() + right.size(), -1); // construct vector with left.size() + right.size() elements assigned to -1
int left_position = 0;
int right_position = 0;
int ret_position = 0;
while (left_position < left.size() && right_position < right.size()) {
double left_value = left[left_position];
double right_value = right[right_position];
if (left_value < right_value) {
ret[ret_position++] = left_value;
left_position++;
} else {
ret[ret_position++] = right_value;
right_position++;
}
}
Corrected code:
#include <iostream>
#include <vector>
std::vector<double> merge(std::vector<double> left, std::vector<double> right);
std::vector<double> mergeSort(std::vector<double> vec);
void sort(std::vector<double>& vec) { // using reference here std::vector<double>& - to be able to change vector inside function
vec = mergeSort(vec);
for (unsigned int i = 0; i < vec.size(); i++){
std::cout << vec[i] << " ";
}
}
std::vector<double> merge(std::vector<double> left, std::vector<double> right) {
std::vector<double> ret(left.size() + right.size(), -1); // construct vector with left.size() + right.size() elements assigned to -1
int left_position = 0;
int right_position = 0;
int ret_position = 0;
while (left_position < left.size() && right_position < right.size()) {
double left_value = left[left_position];
double right_value = right[right_position];
if (left_value < right_value) {
ret[ret_position++] = left_value;
left_position++;
} else {
ret[ret_position++] = right_value;
right_position++;
}
}
while (left_position < left.size()) {
ret[ret_position++] = left[left_position++];
}
while (right_position < right.size()) {
ret[ret_position++] = right[right_position++];
}
return ret;
}
std::vector<double> mergeSort(std::vector<double> vec){
if (vec.size() < 2){
return vec;
}
int middle = vec.size() / 2;
std::vector<double> left(vec.begin(), vec.begin() + middle);
std::vector<double> right(vec.begin() + middle, vec.end());
left = mergeSort(left);
right = mergeSort(right);
std::vector<double> ret = merge(left, right);
return ret;
}
int main(){
std::vector<double> vec;
vec.push_back(7.04);
vec.push_back(8.04);
vec.push_back(6.04);
vec.push_back(9.04);
vec.push_back(1.04);
vec.push_back(3.04);
vec.push_back(5.04);
vec.push_back(2.04);
vec.push_back(10.04);
vec.push_back(4.04);
vec.push_back(12.04);
vec.push_back(11.04);
sort(vec);
return 0;
}
Now the output is
1.04 2.04 3.04 4.04 5.04 6.04 7.04 8.04 9.04 10.04 11.04 12.04
You should read more carefully methods of the class vector.
Here is a good site about c++: http://www.cplusplus.com/reference/vector/vector/

Answer 2

You are forgetting elements when breaking the original set into left and right subsets.
int middle = len / 2;
for (int i = 0; i < middle; i++){
...
}
for (int j = 0; j < middle; j++){
...
}
if len is odd you will end up having 2*middle = len -1. You can change to
for (int j = 0; j < len - middle; j++){
...
}
Edit:
Your whole program is based on the fact that the left and right side have equal length. Which means it will be correct only if the input vector has a length which is a power of 2. You need to revisit your functions with the assumption that there is going to be difference in the size of left and right
Do you really need to pass a length parameter when you deal with vectors? For instance
std::vector<double> ret(len + len);
in the merge function could be
std::vector<double> ret(left.size() + right.size());