C++实现 直接插入排序，选择排序，冒泡排序，快速排序，简单计数排序，归并排序

基于C++的vector容器实现

当然，无论是vector实现也好还是内置数组实现，效果都一样，区别在于使用内置数组时传参需要加上内置数组容量大小。

---

话不多说，直接上代码

直接插入排序：

插入排序在书写时需要注意插入位置 i 是否正确，代码中使用前置自增运算符。

void insertSort(vector<int>& sortVector)     
//插入排序，从前到后，将小于前者的元素前插到前方已有绪队列的合适位置
{
	for (int i = 0; i < sortVector.size()-1; i++)
	{
		if (sortVector[i+1] < sortVector[i])
		{
			int target = sortVector[i + 1];
			while (target < sortVector[i])
			{
				sortVector[i + 1] = sortVector[i];
				i--;
			}
			sortVector[++i] = target;
		}
	}
}

---

选择排序：

选择排序比较简单，两个for循环嵌套且必然是O(N^2)的时间复杂度。

void selectSort(vector<int>& sortVector)			
//选择排序，每一趟选择最小的元素从前往后放置
{
	for (int i = 0; i < sortVector.size(); i++)
	{
		int target = i;
		for (int j = i; j < sortVector.size(); j++)
		{
			if (sortVector[target] > sortVector[j])
			{
				target = j;
			}
			int temp = sortVector[target];
			sortVector[target] = sortVector[i];
			sortVector[i] = temp;
		}
	}
}

---

冒泡排序：

作为交换排序的一种，冒泡排序每一趟必然会有一个元素出现在它的最终位置。
代码中使用的flag作为标志位，用于判断该趟中若无发生任何交换，则冒泡提前结束。

void bubbleSort(vector<int>& sortVector)   
//冒泡排序，相邻元素两两比较，大的往上跑，无交换可提前结束
{
	bool flag = true;
	int i = 0;
	int j = sortVector.size() - 1;
	while(j>=0&&flag)
	{
		flag = false;
		while (i <= j && i+1<sortVector.size())
		{
			if (sortVector[i] > sortVector[i + 1])
			{
				int temp = sortVector[i+1];
				sortVector[i + 1] = sortVector[i];
				sortVector[i] = temp;
				flag = true;
			}
			i++;
		}
		i = 0;
		j --;
	}
}

---

快速排序：

快速排序是交换排序的另一种，同样，每一趟排序后会有一个元素在其最终的位置上，这个元素就是每一趟的枢轴。
采用分治，因此一定要注意保证每一趟 left 比 right 小。

int Partition(vector<int>& sortVector, int left, int right) 
 //实现枢轴左边小于，右边大于，返回枢轴位置
{
	int pivot = sortVector[left];
	int i = left;
	int j = right;
	while (i < j)
	{
		while (i < j && sortVector[j] >= pivot)
			j--;
		sortVector[i] = sortVector[j];
		while (i < j && sortVector[i] <= pivot)
			i++;
		sortVector[j] = sortVector[i];
	}
	sortVector[i] = pivot;
	return i;
}


void quickSort(vector<int>& sortVector, int left, int right)   //分治 快速排序
{
	if (left < right)
	{
		int low = Partition(sortVector, left, right);
		quickSort(sortVector, left, low - 1);
		quickSort(sortVector, low + 1, right);
	}
}

---

计数排序：

计数排序就是只针对非负整数的桶排序，因为数组的下标只能是非负整数。

void countSort(vector<int>& sortVector)     
//计数排序，只适合待排序数均为非负整数
{
	int min = INT_MAX;
	int max = INT_MIN;
	for (int i = 0; i < sortVector.size(); i++)
	{
		if (min > sortVector[i])
			min = sortVector[i];
		if (max < sortVector[i])
			max = sortVector[i];
	}

	int *countArray = new int[max-min+1] {};
	for (int item : sortVector)
	{
		countArray[item - min]++;
	}
	for (int j = 0; j < (max - min+1); j++)
		for (int k = 0; k < countArray[j]; k++)
			cout << (j + min) << " ";
}

---

归并排序：

归并排序，采用分治的思想，层层分开，最终归并为有序的队列。
书写代码时需要注意始终保证 left 小于 right ，同时需要注意将tempVector写回到sortVector时每一段的写入位置。

void Merge(vector<int>& sortVector, int left,int mid, int right)    
//用于归并已分治的数组
{
	int i = left;
	int j = mid + 1;
	int k = 0;
	vector<int> tempVector(right - left+1, 0);

	while (i <= mid && j <= right)
	{
		if (sortVector[i] < sortVector[j])
			tempVector[k++] = sortVector[i++];
		else
			tempVector[k++] = sortVector[j++];
	}
		while (i <= mid)
			tempVector[k++] = sortVector[i++];
		while (j <= right)
			tempVector[k++] = sortVector[j++];

	   for (i = left, k = 0; i <= right; i++, k++)
		           sortVector[i] = tempVector[k];
}

void mergeSort(vector<int>& sortVector, int left, int right)   
//分治数组，归并排序
{
	if (left < right)
	{
		int mid = (left + right) / 2;
		mergeSort(sortVector, left, mid);
		mergeSort(sortVector, mid + 1, right);
		Merge(sortVector, left, mid, right);
	}
}

---

main()函数测试

int main()
{
	vector<int> test = { 1,2,3,6,9,12,2,5,3,4,5,6,3 };
	cout << "origin vector : " << endl;
	for (auto item : test)
		cout << item << " ";

	cout << "\nafter insert sort : " << endl;
	test = { 1,2,3,6,9,12,2,5,3,4,5,6,3 };
	insertSort(test);
	for (auto item : test)
		cout << item << " ";

	cout << "\nafter select sort : " << endl;
	test = { 1,2,3,6,9,12,2,5,3,4,5,6,3 };
	selectSort(test);
	for (auto item : test)
		cout << item << " ";

	cout << "\nafter bubble sort : " << endl;
	test = { 1,2,3,6,9,12,2,5,3,4,5,6,3 };
	bubbleSort(test);
	for (auto item : test)
		cout << item << " ";

	cout << "\nafter quick sort : " << endl;
	test = { 1,2,3,6,9,12,2,5,3,4,5,6,3 };
	quickSort(test,0,test.size()-1);
	for (auto item : test)
		cout << item << " ";
	
	cout << "\nafter count sort : " << endl;
	test = { 1,2,3,6,9,12,2,5,3,4,5,6,3 };
	countSort(test);

	cout << "\nafter merge sort : " << endl;
	test = { 1,2,3,6,9,12,2,5,3,4,5,6,3 };
	mergeSort(test, 0, 12);
	for (auto item : test)
		cout << item << " ";
}

运行结果：

看到这里了，如果对你有帮助的话，不妨点个小心心吧