快速排序，归并排序，堆排序代码实现

快速排序：

vector<int> partition(vector<int>& array, int L, int R)
{
	int less = L - 1;
	int more = R;
	while (L < more)
	{
		if (array[L] < array[R])
		{
			swap(array[++less], array[L++]);
		}
		else if (array[L] == array[R])
		{
			L++;
		}
		else
		{
			swap(array[L], array[--more]);
		}
	}

	swap(array[more], array[R]);
	vector<int>arr(2);
	arr[0] = less ;
	arr[1] = more;
	return arr;
}

void q_sort(vector<int>&array,int L,int R)
{
	if (L >= R) { return; }
	vector<int>arr = partition(array, L, R);

	q_sort(array, L, arr[0]);
	q_sort(array, arr[1] + 1, R);
}


int main()
{
	cout << "num=" << endl;
	vector<int>array;
	int num;
	do
	{
		cin >> num;
		array.push_back(num);
	} while (getchar() != '\n');
	int len = array.size();
	
	q_sort(array,0,len-1);

	for (int i = 0; i < len; ++i)
	{
		cout << array[i] << endl;
	}
	return 0;
}

归并排序：

void Merage(vector<int>& array, int left,int mid, int right)
{
	vector<int> helper(right - left + 1);
	int i = 0;
	int helperLeft = left;
	int helperRight = mid + 1;

	while (helperLeft <= mid && helperRight <= right) {
		if (array[helperLeft] < array[helperRight]) {
			helper[i++] = array[helperLeft++];
		}
		else {
			helper[i++] = array[helperRight++];
		}
	}
	while (helperLeft <= mid) {
		helper[i++] = array[helperLeft++];
	}
	while (helperRight <= right) {
		helper[i++] = array[helperRight++];
	}
	for (i = 0; i < helper.size(); i++)
		array[left + i] = helper[i];//备份
}

void Merage_sort(vector<int>&array,int L,int R)
{
	if (L < R) 
	{
		int mid = L + (R - L) / 2;
		Merage_sort(array, L, mid);
		Merage_sort(array, mid + 1, R);
		Merage(array, L, mid, R);
	}
}

int main()
{
	cout << "数组为：" << endl;
	vector<int>array;
	int num;
	do
	{
		cin >> num;
		array.emplace_back(num);
	} while (getchar() != '\n');
	int len = array.size();
	Merage_sort(array,0,len -1);

	for (int a : array)
	{
		cout << a << " ";
	}
	return 0;
	
}

堆排序：

void heapInsert(vector<int>& arr, int index)
{
	while (arr[index] > arr[(index -1)/2])
	{
		swap(arr[index], arr[(index - 1) / 2]);
		index = (index -1)/2;
	}
}
void heapify(vector<int>& arr, int index, int heapsize)
{
	int left = index * 2 + 1;//左孩子节点

	while (left < heapsize) {
		int largest;
		if (left + 1 < heapsize && arr[left + 1] > arr[left])
			largest = left + 1;
		else
			largest = left;
		if (arr[largest] < arr[index]) {
			largest = index;
		}
		if (largest == index)
		{
			break;
		}
		else
		{
			swap(arr[largest], arr[index]);
			index = largest;
			left = index * 2 + 1;
		}
	}

}
void heap_sort(vector<int>&arr)
{
	if (arr.empty() == true || arr.size() < 2) {
		return;
	}
	for (int i = 0; i < arr.size(); i++)
	{
		heapInsert(arr, i);
	}
	int heapsize = arr.size();
	swap(arr[0], arr[--heapsize]);
	while (heapsize > 0)
	{
		heapify(arr, 0, heapsize);
		swap(arr[0], arr[--heapsize]);
	}
	

}

int main()
{
	vector<int>array;
	int num;
	do
	{
		cin >> num;
		array.push_back(num);
	} while (getchar() != '\n');
	int len = array.size();
	heap_sort(array);

	for (int i = 0; i < len; i++)
	{
		cout << array[i] << endl;
	}

	return 0;
}