SUMMARY OF BASIC ALGORITHMS

TO REVIEW BASIC ALGORITHMS, I DECIDE TO SUMMARIZE THEM BY MYSELF.

 

void insertion_sort(vector<int>&v)
{
	for (int i = 0; i < v.size(); ++i)
	{
		int tmp = v[i], j = i;
		while (j > 0 && v[j - 1] > tmp)
		{
			v[j] = v[j - 1];
			--j;
		}
		v[j] = tmp;
	}
}

 

 

 

void merge_sort(vector<int>&v, int s, int e)
{
	if (e <= s + 1)return;

	int mid = (s + e) / 2;
	merge_sort(v, s, mid);
	merge_sort(v, mid, e);

	vector<int>pre, post;
	for (int i = s; i < mid; ++i)
		pre.push_back(v[i]);
	for (int i = mid; i < e; ++i)
		post.push_back(v[i]);
	for (int i = s, j = 0, k = 0; i < e; ++i)
	{
		if (j < pre.size() && k < post.size())
			v[i] = (pre[j] > post[k] ? post[k++] : pre[j++]);
		else if (j < pre.size())
			v[i] = pre[j++];
		else
			v[i] = post[k++];
	}
}

 

 

void max_heapify(vector<int>&v,int i, int end) {
	int left;
	while ((left = 2 * i + 1) <= end ) {
		int mc = left + 1 <= end && v[left + 1] > v[left] ? left + 1 : left;
		if (v[mc] > v[i]) {
			swap(v[i], v[mc]);
			i = mc;
		}
		else {
			break;
		}
	}
}


void heap_sort(vector<int>&v) {
	for (int i = v.size() / 2 - 1; i >= 0; --i) {
		max_heapify(v, i, v.size() - 1);
	}

	for (int i = v.size() - 1; i >= 0; --i) {
		swap(v[0], v[i]);
		max_heapify(v, 0, i-1);
	}
}

 

 

 

int partition(vector<int>&v, int s, int e) {
	int first = s;
	for (int i = s + 1; i <= e; ++i) {
		if (v[i] <= v[s]) {
			swap(v[++first], v[i]);
		}
	}
	swap(v[s], v[first]);
	return first;
}


void q_sort(vector<int>&v, int s, int e) {
	if (s >= e)return;
	int pt = partition(v, s, e);
	q_sort(v, s, pt - 1);
	q_sort(v, pt + 1, e);
}

void quick_sort(vector<int>&v) {
	q_sort(v, 0, v.size() - 1);
}