合并排序非递归实现

/*
 * MergeSort.cpp
 *
 *  Created on: 2014-3-21
 *      Author: root
 */

#include <iostream>
#include <vector>
using namespace std;

class MergeSort {
private:
	vector<int> src;
	vector<int> dst;
public:
	void init();
	void mergeSort();
	void merge(vector<int>::iterator iter_src, vector<int>::iterator iter_dst,
			int p, int q, int r);
	void mergePass(vector<int>::iterator iter_src,
			vector<int>::iterator iter_dst, int s, int length);
	void traverse();
	void traverse_dst();
	vector<int>::iterator getSrcIterBegin();
	vector<int>::iterator getDstIterBegin();
};
vector<int>::iterator MergeSort::getSrcIterBegin() {
	return src.begin();
}
vector<int>::iterator MergeSort::getDstIterBegin() {
	return dst.begin();
}
void MergeSort::mergeSort() {
	int s = 1;
	int length = src.size();
	while (s < length) {
		mergePass(src.begin(), dst.begin(), s, length);
		//traverse_dst();
		s *= 2;
		mergePass(dst.begin(), src.begin(), s, length);
		//traverse();
		s *= 2;
	}
}
void MergeSort::mergePass(vector<int>::iterator iter_src_b,
		vector<int>::iterator iter_dst_b, int s, int length) {
	int i = 0;
	while (i + 2 * s < length) {
		merge(iter_src_b, iter_dst_b, i, i + s - 1, i + 2 * s - 1);
		i += 2 * s;
	}
	if (i + s < length) {
		merge(iter_src_b, iter_dst_b, i, i + s - 1, length - 1);
	} else {
		vector<int>::iterator iter_src = iter_src_b + i;
		vector<int>::iterator iter_dst = iter_dst_b + i;
		for (int j = i; j < length; j++) {
			*iter_dst++ = *iter_src++;
		}
	}
}
void MergeSort::merge(vector<int>::iterator iter_src_b,
		vector<int>::iterator iter_dst_b, int p, int q, int r) {
	int len1 = q - p + 1;
	int len2 = r - q;
	vector<int>::iterator iter_src_b1 = iter_src_b + p;
	vector<int>::iterator iter_src_e1 = iter_src_b1 + len1;
	vector<int>::iterator iter_src_b2 = iter_src_e1;
	vector<int>::iterator iter_src_e2 = iter_src_b2 + len2;
	vector<int>::iterator iter_dst = iter_dst_b + p;
	while (iter_src_b1 != iter_src_e1 && iter_src_b2 != iter_src_e2) {
		if (*iter_src_b1 < *iter_src_b2) {
			*iter_dst++ = *iter_src_b1++;
		} else {
			*iter_dst++ = *iter_src_b2++;
		}
	}
	if (iter_src_b1 != iter_src_e1) {
		*iter_dst++ = *iter_src_b1++;
	}
	if (iter_src_b2 != iter_src_e2) {
		*iter_dst++ = *iter_src_b2++;
	}
}
void MergeSort::traverse() {
	vector<int>::iterator iter;
	for (iter = src.begin(); iter != src.end(); iter++) {
		std::cout << *iter << endl;
	}
}
void MergeSort::traverse_dst() {
	vector<int>::iterator iter;
	for (iter = dst.begin(); iter != dst.end(); iter++) {
		std::cout << *iter << endl;
	}
}
void MergeSort::init() {
	int count;
	int element;
	std::cout << "how many elements do you want to enter: ";
	std::cin >> count;
	for (int i = 0; i < count; i++) {
		std::cin >> element;
		src.push_back(element);
	}
	dst.resize(src.size());
}
int main() {
	MergeSort *ms = new MergeSort();
	ms->init();
	ms->mergeSort();
	ms->traverse();
	delete ms;
}