八个常见排序算法

八个常见排序算法原理解释和代码

#include "sort.h"
//冒泡排序
	/*冒泡排序的原理是相邻两个元素比较，将较大的移到后面，以此类推到整个数组，
	每次遍历只需要遍历未排序内容即可。时间复杂度O（n^2），空间复杂度O（1），稳定*/
void Sort::BubbleSort(vector<int>& arr)
{
	for (int i = arr.size() - 1; i > 0; i--)
	{
		for (int j = 0; j < i; j++)
		{
			if (arr[j] > arr[j + 1])
				swap(arr[j], arr[j + 1]);
		}
	}
}
//选择排序
/*选择排序的原理：第一次遍历选择一个最小的放在左边，
第二次遍历在剩下的元素中选择最小的一个放在左边以此类推，时间复杂度O（n^2），空间复杂度O（1），不稳定*/
void Sort::SelectionSort(vector<int>& arr)
{
	for (int i = 0; i < arr.size() - 1; i++)
	{
		int minindex = i;
		for (int j = i; j < arr.size() - 1; j++)
		{
			if (arr[minindex] > arr[j + 1])
				minindex = j + 1;
		}
		if(minindex != i)
			swap(arr[i], arr[minindex]);
	}
}
//插入排序
/*插入排序原理：将无序序列里面的元素插入到有序序列里面，一般将数组的第一个元素作为一个有序序列，
然后剩下的作为无序序列，从无序序列中选出第一个元素和有序序列中的元素比较，插入到合适的位置
时间复杂度O（n^2），空间复杂度O（1），稳定*/
void Sort::InsertSort(vector<int>& arr)
{
	for (int i = 1; i < arr.size(); i++)
	{
		int key = arr[i],j;
		for (j = i - 1; j >= 0 && key < arr[j]; j--)
			arr[j+1] = arr[j];
		arr[j + 1] = key;
	}
}
//二分插入排序
/*二分插入排序原理：其是插入排序的变种，在查找有序序列时采用二分法查找，
时间复杂度O（n^2），空间复杂度O（1），稳定*/
void Sort::InsertSort2(vector<int>& arr)
{
	for (int i = 1; i < arr.size(); i++)
	{
		int key = arr[i], j;
		int L=0,R=i-1;
		while (L <= R)
		{
			int mid = L + (R - L) / 2;
			if (arr[mid] > key)
				R = mid - 1;
			else
				L = mid + 1;
		}
		for (j = i - 1; j >= L ; j--)
			arr[j + 1] = arr[j];
		arr[j + 1] = key;
	}
}
//希尔排序
/*希尔排序原理：将数组分为若干子序列分别进行插入排序，子序列都有序时，进行整体得插入排序
时间复杂度最坏O（n^2），空间复杂度O（1），稳定*/
void Sort::ShellSort(vector<int>& arr)
{
	int len = arr.size();
	int increasement = len;
	do {
		increasement = increasement / 3 + 1;
		for (int i = 0; i < len; i++)
		{
			for (int j = i + increasement; j < len; j += increasement)
			{
				int key = arr[j],s;
				for (s = j - increasement; s >= 0 && key < arr[s]; s -= increasement)
				{
					arr[s + increasement] = arr[s];
				}
				arr[s + increasement] = key;
			}
		}

	} while (increasement > 1);
}

//快速排序
/*快速排序原理：在序列中选出一个基准值，一般选第一个，然后将大于基准值得元素全都放到基准值右边，
小于的放在左边，时间复杂度最优O（nlogn）最坏O（n^2），空间复杂度O（logn），稳定*/
void Sort::quickSort(vector<int>& arr, int start,int end)
{
	if (start >= end)
		return;
	int base = arr[start];
	int L = start, R = end;
	while (L<R)
	{
		while (L<R && arr[R]>=base)
		{
			R--;
		}
		if (L < R)
		{
			arr[L] = arr[R];
			L++;
		}
		while (L<R && arr[L]<base)
		{
			L++;
		}
		if (L < R)
		{
			arr[R] = arr[L];
			R--;
		}
	

	}
	arr[L] = base;
	quickSort(arr, start, L-1);
	quickSort(arr, L+1, end);
}
//归并排序
/*归并排序原理：将一个n序列可以看成n个子序列，然后两两归并，归并的时候把小的元素放到前面，得到多个有序序列，在继续归并排序，
直到达到n个，时间复杂度O（nlogn），空间复杂度O（n），稳定*/
void Sort::merge(vector<int>& arr, int start,int mid, int end)
{
	vector<int>temp(end - start + 1);
	int i = start,k=0;
	int j = mid+1;
	while (i <= mid && j <= end)
	{
		if (arr[i] < arr[j])
			temp[k++] = arr[i++];
		else
			temp[k++] = arr[j++];
	}
	while (i <= mid)
	{
		temp[k++] = arr[i++];
	}
	while (j <= end)
	{
		temp[k++] = arr[j++];
	}
	for (int p = 0; p < k; p++)
	{
		arr[start + p] = temp[p];
	}
}
void Sort::mergeSort(vector<int>& arr, int start, int end)
{
	if (start >= end)
		return;
	int mid = start + (end - start) / 2;
	mergeSort(arr, start, mid);
	mergeSort(arr, mid+1, end);
	merge(arr, start, mid, end);
}
//堆排序
/*堆排序原理：将序列看成一个二叉树，然后将待排序列看成一个大顶堆（小顶堆：从大到小），大顶堆表示结点上的值比左
右子树的值都大，最大的值是根节点，排好以后将堆顶元素和末尾元素交换，剩下的元素重新构造大顶堆，反复执行
时间复杂度O（nlogn），空间复杂度O（1），不稳定*/
void Sort::Heapadjust(vector<int>& arr, int start, int end)
{
	int dad = start;
	int son = dad * 2 + 1;
	while (son <= end)
	{
		if (son + 1 <= end && arr[son] < arr[son + 1])
			son++;
		if (arr[dad] > arr[son])
			return;
		else
		{
			swap(arr[son], arr[dad]);
			dad = son;
			son = dad * 2 + 1;
		}
	}
}
void Sort::HeapSort(vector<int>& arr)
{
	int len = arr.size(),i,j;
	for (i = len / 2 - 1; i >= 0; i--)//从第一个非叶子节点开始
	{
		Heapadjust(arr, i, len-1);
	}
	for (i = len - 1; i >0; i--)
	{
		swap(arr[i], arr[0]);
		Heapadjust(arr, 0, i-1);
	}
}