C++实现快速排序 希尔排序 插入排序 冒泡排序 选择排序 归并排序

直接上代码，有问题私聊

#include<iostream>
#include <vector>
#include<time.h>
using namespace std;
//输出排序好函数的值
void printvalue(vector<int>nums,int size)
{
	for (int value=0;value<size;value++)
		cout << nums[value] << endl;
}
//工具函数交换两个函数的值
void swap(int& a, int& b)
{
	int tem = a;
	a = b;
	b = tem;
}
//随机生成数组进行测试
void Gengrate(vector<int>& test, int size)
{
	srand(time(NULL));
	for (int i = 0; i < size; i++)
	{
		test.push_back(rand() % (size));

	}
}
//归并排序

void _merge(vector<int>&a, int low, int mid, int high)
{   //分支
	int left = low;
	int right = mid+1;
	int k = low;
	vector<int>tem(a.size());

	while (left < mid + 1 && right < high + 1)
	{
	//	cout << "mid  " << mid << endl;
		if (a[left] < a[right])
		{
			tem[k++] = a[left++];
		}
		else
		{
			tem[k++] = a[right++];
		}
	}
	while (left < mid + 1)
	{
		tem[k++] = a[left++];
	}
	while (right < high + 1)
	{
		tem[k++] = a[right++];
	}
	for (int i = low; i < high + 1; i++)
	{
		a[i] = tem[i];
	}


}
void merge_sort(vector<int>&a, int low, int high)
{
	//出口条件
	if (low >= high)
		return;
	int mid = low + ((high - low) >>1);
	//cout << "mid  " <<mid<<  endl;
	merge_sort(a,low,mid);
	merge_sort(a,mid+1,high);
	_merge(a,low,mid,high);

}

//快速排序返回位置的函数
int returnpos(vector<int>& nums, int low, int high)
{
	int value = nums[low];
	while (low < high)
	{
		while (low<high && nums[high]>=value)
			high--;
		swap(nums[high],nums[low]);
		while (low < high && nums[low] <=value)
			low++;
		swap(nums[high],nums[low]);
	}
	return low;
}
//快速排序
//通常选取第一个值作为比较值，交换前后的顺序
void quicksort(vector<int>&nums,int low,int high)
{
	//快速排序是通过两两相互比较，交换值
	if (low < high)
	{
		int pos = returnpos(nums, low, high);
		quicksort(nums,low,pos-1);
		quicksort(nums,pos+1, high);
	}
}

//冒泡排序
void bubblesort(vector<int>&nums)
{
	bool flag = true;
	for (int i = 0; i < nums.size()&&flag; i++)
	{
		flag = false;
		for (int j = nums.size() - 1; j > i; j--)
		{
			if (nums[j - 1] > nums[j])
			{
				swap(nums[j - 1], nums[j]);
				flag = true;
			}
		}

	}
}


//直接插入排序
void InsertSort(vector<int>&nums)
{   //从第一个元素开始默认与前一个元素比较
	for (int i = 1; i < nums.size(); i++)
	{
		int key = nums[i];
		int index = i - 1;
	
		while (index >= 0 &&nums[index]>key)
		{
			nums[index + 1] = key;
			index--;

		}
		nums[index + 1] = key;
	}
}


//选择排序
void SelectSort(vector<int>& nums)
{
	for (int i = 0; i < nums.size(); i++)
	{
		for (int j = i + 1; j < nums.size(); j++)
		{
			if (nums[i] > nums[j])
				swap(nums[i],nums[j]);
		}
	}
}

//希尔排序
void ShellSort(vector<int>& nums)
{

	for (int i= nums.size() / 2;i > 0; i = i / 2)
	{
		for (int j = i; j < nums.size(); j++)
		{   
			
				int key = nums[j];
				int index = j - i;
				while (index >= 0 && nums[index] > key)
				{
					nums[index + i] = nums[index];
					index -= i;
				}
				nums[index + i] = key;

	
		}


	}
}




int main()
{   
	int size = 1000;
	vector<int>test;
	

	Gengrate(test, size);
	clock_t Merge_start = clock();
	merge_sort(test,0, size-1);
	cout << "归并排序所用时间为" << (double)(clock() - Merge_start) / CLOCKS_PER_SEC << endl;
	printvalue(test,size);
	//快速排序
	Gengrate(test, size);
	clock_t start=clock();
	quicksort(test,0,size-1);
	cout << "快速排序所用时间为" <<(double)(clock() - start)/CLOCKS_PER_SEC<< endl;
	printvalue(test, size);
	clock_t bubbletime = clock();
	Gengrate(test, size);
	bubblesort(test);
	cout << "冒泡所用时间" << (double)(clock() - bubbletime) / CLOCKS_PER_SEC << endl;
	printvalue(test,size);

	clock_t InsertTime = clock();
	Gengrate(test, size);
	InsertSort(test);
	cout << "直接插入排序所用时间" << (double)(clock() -InsertTime) / CLOCKS_PER_SEC << endl;
	printvalue(test, size);



	clock_t ShellSortTime = clock();
	Gengrate(test, size);
	ShellSort(test);
	cout << "希尔排序所用时间" << (double)(clock() - ShellSortTime) / CLOCKS_PER_SEC << endl;
	printvalue(test, 100);


	clock_t SelectTime = clock();
	Gengrate(test, size);
	SelectSort(test);
	cout << "选择排序所用时间" << (double)(clock() - SelectTime) / CLOCKS_PER_SEC << endl;
	printvalue(test, 10);


	return 0;
}

最近翻看又重新写了一版加新记忆

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

void vector_print(vector<int>data)
{
	for (int value : data)
		cout << "数据是 " << value << endl;
}

/****************************
*   冒泡排序 关键在于两两相邻比较
*
*
*
*/
void Bubble_Sort_1(vector<int>& data)
{
	for (int i = 0; i < data.size(); i++)
	{
		for (int j = i + 1; j < data.size(); j--)
		{
			if (data[i] > data[j])
				swap(data[i],data[j]);
		}
	}
}
/****************************
*   冒泡排序 关键在于两两相邻比较
*   有两两相邻比较，两个相邻比较之后交换之后对之后的排序有帮助
*	小的值就像气泡慢慢飘起
*
*/
void Bubble_Sort_2(vector<int>& data)
{
	for (int i = 0; i < data.size(); i++)
	{
		for (int j = data.size()-2; j >=i; j++)
		{
			if (data[j] > data[j+1])
				swap(data[j], data[j+1]);
		}
	}
}
/****************************
*   冒泡排序 优化
*   设置标志减少不必要的排序
*    N-1次比较时间复杂度 o(n2)
*/
void Bubble_Sort_3(vector<int>& data)
{
	bool flag = true;
	for (int i = 0; i < data.size()&&flag; i++)
	{    
		flag = false;
		for (int j = data.size() - 2; j >= i; j--)
		{
			if (data[j] > data[j + 1])
			{
				swap(data[j], data[j + 1]);
				flag = true;
			}
				
		}
	}
}


/******
*简单选择排序
* 直接交换最小的减少交换的次数
*也是冒泡排序的一种改进 减少了交换的次数
*
******/
void Simple_Sort(vector<int>& data)
{
	for (int i = 0; i < data.size(); i++)
	{
		int min = i;
		for (int j = i + 1; j < data.size(); j++)
		{
			if (data[j] < data[min])
				min = j;


		}
		if (min != i)
			swap(data[min],data[i]);
	}
}



/******
*直接插入排序
*直接插入排序的基本操作是将一个记录插入到已经排好序的有序表中，从而得到一个新的记录数量增1的有序表
*依然是n2但是效率比以上都高一点。适用于记录数量比较小或者已经基本有序。
******/
void Insert_Sort(vector<int>&data)
{
	for (int i = 1; i < data.size(); i++)
	{   
		int index = i - 1;
		int value = data[i];
			while (index >= 0 && value < data[index])
			{
				data[index + 1] = data[index];
				index--;
			}
			data[index] = value;
	}
}




/******
*希尔排序
*对直接插入排序的一种改进
* 
******/
void Shell_Sort(vector<int>& data)
{
	int size = data.size();
	for (int gap= size / 3 + 1; gap >= 1; gap = gap / 3 + 1)
	{
		
		for (int index = gap; index < data.size(); index++)
		{
			int key = data[index];
			int currindex = index - gap;
			while (currindex >= 0 && key < data[currindex])
			{
			
				data[currindex + gap] = data[currindex];
				currindex = currindex - gap;

			}
			data[currindex + gap] = key;
			
		}
		if (gap == 1)
			break;
	}
}

/***************************
*堆排序 
*构造大顶堆小顶堆不停交换顺序
* 
*时间复杂度为nlogn 不稳定排序不太适合排序序列个数较少的情况
* 
***************************/

void Adjust_Heap(vector<int>&data,int i,int length)
{
	int temp = data[i];
	//得到该节点左右节点最大值
	for (int k = 2 * i + 1; k < length; k = 2 * k + 1)
	{
		if (k + 1 < length && data[k + 1] > data[k])
			k++;
		//不需要交换因为可能遍历孙子节点出现不正确的情况，只需要将左右孩子节点的最大赋值给根节点可以，记录位置
		if (data[k] > temp)
		{
			data[i] = data[k];
			i = k;
		}
		else
			break;
	}

	data[i] = temp;
}
void Heap_Sort(vector<int>&data)
{
	//构造大顶堆 从下向上进行构造第一非叶子节点进行构造
	for (int i = data.size() / 2 - 1; i >= 0; i--)
	{
		Adjust_Heap(data, i, data.size());
	}
	//交换堆顶元素与末尾元素
	for (int j = data.size() - 1; j > 0; j--)
	{
		swap(data[j], data[0]);
		Adjust_Heap(data, 0, j);

	}
}


/**************************
*归并排序
*左闭右闭
*分而治之
**********************/

//处理部分
void _Merge(vector<int>&data,int left,int mid,int right)
{
	//左半边部分
	int low = left;
	//右半边部分；
	int high = mid + 1;
	vector<int>temp(data.size());
	int index =left;
	while (low <= mid && high <= right)
	{
	
		if (data[low] < data[high])
			temp[index++] = data[low++];
		else
			temp[index++] = data[high++];	
	}

	while (low <= mid)
	{
	
		temp[index++] = data[low++];

	}

	while (high <= right)
	{

		temp[index++] = data[high++];
	}
;
	for (int i = left; i <=right; i++)
	{

		data[i] = temp[i];
	}
}


//分的部分
void Merge_Sort(vector<int>& data, int left, int right)
{
	if (left >= right)
		return;

	int mid = left + ((right - left) /2);

	Merge_Sort(data, left, mid);
	Merge_Sort(data, mid + 1, right);


	_Merge(data,left,mid,right);

}

int Local_Pos(vector<int>& data, int low, int high)
{

	int value = data[low];

	while (low < high)
	{
		while (low < high && data[high] >= value)
			high--;
		swap(data[high], data[low]);

		while (low < high && data[low] <= value)
			low++;
		swap(data[high], data[low]);
	}
	

	return low;

}
void Quick_Sort(vector<int>&data,int left,int right)
{
	if (left < right)
	{
		int pos = Local_Pos(data,left,right);
		Quick_Sort(data,left,pos-1);
		Quick_Sort(data,pos+1,right);
	}


}


int main()
{
	vector<int> data = { 2,23,43,7,5,6,8,13 };
	//Shell_Sort(data);
//	Bubble_Sort_3(data);
//	Heap_Sort(data);
//	Merge_Sort(data,0,data.size()-1);
	Quick_Sort(data, 0, data.size() - 1);
	vector_print(data);
}