数据结构整理之常用排序算法（冒泡、插入、选择、快速、堆排）

//
下面文档中为常用排序算法，关于代码详细介绍后面会补充，都调试过，可以拿去直接使用
//

 

#include<iostream>
#include<vector>
#include<vector>
#include<time.h>
using namespace std;

class my_sort 
{
public:
	void swap(int &a, int &b);
	void bubble_sort(vector<int> &vec);//冒泡排序
	void quick_sort(vector<int> &vec,int left,int right);//快速排序
	int partition(vector<int>&vec, int left, int right);
	void insert_sort(vector<int> &vec);//插入排序
	void selection_sort(vector<int> &vec);
	void heap_sort(vector<int> &vec);
	void heap_adjust(vector<int> &vec,int start,int end);
};
void my_sort::swap(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}

//冒泡排序*****************************
void my_sort::bubble_sort(vector<int> &vec)
{
	if (vec.size() < 2)
	{
		return;
	}
	for (int i = vec.size() - 1; i > 0; i--)
	{
		for (int j = 0; j < i; j++)
		{
			if (vec[j] > vec[j + 1])
			{
				swap(vec[j], vec[j + 1]);
			}
		}
	}
}
//冒泡排序*****************************

//插入排序*****************************
void my_sort::insert_sort(vector<int> &vec)
{
	if (vec.size() < 2)
	{
		return;
	}
	for (int i = 1; i < vec.size(); i++)
	{
		int j = i - 1;
		int temp = vec[i];
		while(j >= 0&& vec[j] > temp)
		{
			vec[j + 1] = vec[j];
			j--;
		}
		vec[j + 1] = temp;
	}
}
//插入排序*****************************

//选择排序*****************************
void my_sort::selection_sort(vector<int> &vec)
{
	if (vec.size() < 2)
	{
		return;
	}
	for (int i = 0; i < vec.size() - 1; i++)
	{
		for (int j = i + 1; j < vec.size(); j++)
		{
			if (vec[i] > vec[j])
			{
				swap(vec[i], vec[j]);
			}
		}
	}
}
//选择排序*****************************

//堆排序*****************************
void my_sort::heap_adjust(vector<int> &vec,int start,int end)
{
	int temp = vec[start];
	for (int i = 2 * start + 1; i < end; i = 2 * i + 1)
	{
		if (i < end - 1 && vec[i] < vec[i + 1])
		{
			i++;
		}
		if (vec[i] > vec[start])
		{
			vec[start] = vec[i];
			start = i;
		}
		else
		{
			break;
		}
		vec[start] = temp;
	}
}
void my_sort::heap_sort(vector<int> &vec)
{
	if (vec.size() < 2)
	{
		return;
	}
	for (int i = (vec.size() - 1) / 2; i >= 0; i--)
	{
		heap_adjust(vec, i, vec.size());
	}
	for (int i = vec.size() - 1; i > 0; i--)
	{
		swap(vec[i], vec[0]);
		heap_adjust(vec, 0, i);
	}
}
//堆排序*****************************

//快速排序*****************************
void my_sort::quick_sort(vector<int> &vec, int left, int right)
{
	if (vec.size() < 2)
	{
		return;
	}
	int mid = partition(vec, left, right);
	if (mid - 1 > left)
	{
		quick_sort(vec, left, mid - 1);
	}
	if (mid + 1 < right)
	{
		quick_sort(vec, mid + 1, right);
	}
}
int my_sort::partition(vector<int>&vec, int left, int right)
{
	swap(vec[left], vec[left + rand() % (right - left + 1)]);//随机快排，去掉之后为传统排序
	cout << vec[left] << endl;
	int cmp = vec[left];
	while (left < right)
	{
		while (left <right&&vec[right] > cmp)
		{
			right--;
		}
		vec[left] = vec[right];
		while (left < right&&vec[left] <= cmp)
		{
			left++;
		}
		vec[right] = vec[left];
	}
	vec[left] = cmp;
	return left;
}
//快速排序*****************************
int main()
{
	vector<int> vec = { 10, 100,80,1,58,23,25,4,10,2525,23,98,47 };
	my_sort solve;
	//solve.bubble_sort(vec);
	//solve.quick_sort(vec, 0, vec.size() - 1);
	//solve.insert_sort(vec);
	solve.selection_sort(vec);
	for (int i = 0; i < vec.size(); i++)
	{
		cout << vec[i] << " ";
	}
	return 0;
}