面试常见的排序算法

一、各个排序算法的时间复杂度

一、归并排序

归并思想

思想:将两个有序的数组合并成一个有序的数组。

第一步

将数组进行分解，当分解成单个元素为一组的时候才是组内有序的。

第二步

将两两有序的数组进行合并，将两个有序数组合并成一个有序数组。重复第二步，直至排序完成。

合并的步骤:先申请两数组合并后那么大小的空间，然后将两个排好序的数组逐一进行比较，往申请空间里面放。

递归前进:自己调用自己的语句

递归回退:return,通过递归结束条件进行回退

在哪里调用的函数，函数的返回值就返回到哪里

#include
#include
using namespace std;

void Merg(vector& vec, int L, int mid, int R) {
	vectortemp(R-L+1);
	int i = L, j = mid + 1;
	int index = 0;
	while (i <= mid && j <= R) {
		if (vec[i] < vec[j]) {
			temp[index++] = vec[i++];
		}
		else {
			temp[index++] = vec[j++];
		}		
	}
	 while (i <= mid) {
		temp[index++] = vec[i++];
		}	
	while (j <= R) {
		temp[index++] = vec[j++];
		}
	//把排好序的放回原数组
		index = L;
		for (auto it:temp) {
			vec[index++] = it;
		}
}
void Merg_sort(vector& vec, int L, int R) {
	if (L >= R) return;
	int mid = (R - L) / 2 + L;
	Merg_sort(vec, L, mid);
	Merg_sort(vec, mid + 1, R);
	//合并
	Merg(vec, L, mid, R);
}
int main() {
	int num;
	vectorvec;
	 while (cin >> num) {
        vec.push_back(num);
    }
	Merg_sort(vec,0,vec.size()-1);
	for (auto it : vec) {
		cout << it << " ";
	}
	return 0;
}

二、堆排序

第一步:

我们将待排序数组形象成一个堆结构，并将其调整为最大堆

(堆结构:左孩子的下标是2* i+1，右孩子下标2*i+2)

(最大堆的特点:在这个 堆结构里，任何一个父节点的值都大于其子节点的值)

第二步:

将堆顶元素与待排序数组（假设待排序的数据数量为nums)最后一个元素进行交换，swap(a[0], a[nums-1]);

第三步:

待排序的数据量减少一个,即num--;将待排序数组重新调整成最大堆结构，重复第二步，循环n-1次，将所有数据排序完成。

初始化堆（将数组调整成最大堆)

从最后一个父节点开始调整(即i = n/2-1)

#include
#include
using namespace std;

//将子树调整为最大堆
void Adjust(vector& vec, int start, int end) {  //start最开始调整时start不断变化，交换时end不断缩小
	int father = start;    //当前子树结点
	int child = father * 2 + 1;   //左子树
	while (child <= end) { //不断向下调整防止破坏子树，用end来结束循环防止循环内数组访问越界（调整子树的子树的时候）
		if (child + 1 <= end && vec[child] < vec[child + 1]) {  //child+1判断右子树是否越界
			child++;
		}
		if (vec[father] < vec[child]) {
			swap(vec[father], vec[child]);
	//帮助调整子树的最大堆结构，只有和子树的根节点交换了才可能需要向下调整子树
		father = child;
		child = father * 2 + 1;
		}
		else {
			break;  //如果没交换child就会改变 会死循环
		}
	}
}
//堆排序的整个流程
void Heap_sort(vector& vec)
{
	int n = vec.size(); //完全二叉树中结点个数

	//最后一个有子节点的下标为n/2-1;
	for (int i = n / 2 - 1; i >= 0; i--) {
		Adjust(vec, i, n - 1);  //end不受限制因为可能破坏子树结构向下调整
	}

	for (int i = n - 1; i >= 0; i--)  //i是下标
	{
		//交换堆顶和待排序元素中的最后一个元素
		swap(vec[0], vec[i]);

	//把剩下的待排序元素调整成最大堆结构
	Adjust(vec, 0, i - 1); //为啥到i-1，因为Adjust的区间是左闭右闭
	}
}
int  main() {
	vectorvec;
	int n;
	while(cin>>n){
		vec.push_back(n);
	}
	Heap_sort(vec);
	for (auto it:vec) {
		cout << it << " ";
	}

	return 0;
   }

三、快速排序

1、 在数组中选一个基准数（通常为数组第一个）；

2、将数组中小于基准数的数据移到基准数左边，大于基准数的移到右边；

3、对于基准数左、右两边的数组，不断重复以上两个过程，直到每个子集只有一个元素，即为全部有序。

 

#include 
#include
#include 
using namespace std;
int part(vector& nums, int l, int r)  //划分函数
{
	int m=l+rand()%(r-l+1);
    swap(nums[m],nums[l]);
	int i = l, j = r, pivot = nums[l]; //基准元素
	while (i < j)
	{
		while (ipivot) //从右向左开始找一个 小于等于 pivot的数值
		{
			j--;
		}
		if (i < j)
		{
			swap(nums[i++],nums[j]);  //r[i]和r[j]交换后 i 向右移动一位
		}
		while (i < j && nums[i] <= pivot) //从左向右开始找一个 大于 pivot的数值
		{
			i++;
		}
		if (i < j)
		{
			swap(nums[i], nums[j--]);  //r[i]和r[j]交换后 i 向左移动一位
		}
	}
	return i;  //返回最终划分完成后基准元素所在的位置
}
void Quicksort(vector& nums, int l, int r)
{
	int mid;
	if (l < r)
	{
		mid = part(nums, l, r);  // 返回基准元素位置
		Quicksort(nums, l, mid - 1); // 左区间递归快速排序
		Quicksort(nums, mid+1, r); // 右区间递归快速排序
	}
}
int main()
{
	vector vec;
	int n;
	while(cin>>n){
		vec.push_back(n);
	}
	Quicksort(vec, 0, vec.size()-1);
	for (auto it:vec) {
	cout << it << " ";
	}

	return 0;
}

四、冒泡排序

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

#include
#include
using namespace std;

void swap(int* a, int* b) {
	int c = *a;
	*a = *b;
	*b = c;
}
void BubbleSort(int arr[],int n) {
	for (int i = 1; i < n; i++) {   
	int flat=0;
		for (int j = 0; j < n - i; j++) {
			if (arr[j] > arr[j + 1]) {
				swap(&arr[j], &arr[j + 1]);
				flat=1;
			}
		}
		if(flat==0){
		return;
		}
	}
}
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
    cin >> arr[i];
}
BubbleSort(arr, n);
for (int i = 0; i < n; i++) {
    cout << arr[i] << " ";
}

	return 0;
}