面试题:冒泡排序,选择排序,插入排序,快速排序,归并排序,堆排序

本文详细介绍了常见的排序算法,包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序。分析了它们的主要思想、优缺点以及时间复杂度,帮助理解各种排序算法的工作原理。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

面试题之各种排序,现整理如下:


冒泡排序

最常见排序之一,主要算法思想是:最下面数据依次与其相邻数据相比较,如果比相邻数据小,则交换,以此类推,直到最小的数放在最上层,形似冒泡,代码如下:

void bubblesort(int a[],int len)
{
	for (int i = 0; i < len; i++)
	{
		for (int j = len -1; j > i; j--)	//顺序比较相邻两个数,将小者冒上来
		{
			if (a[j] < a[j-1])
			{
				int temp = a[j];
				a[j] = a[j-1];
				a[j-1] = temp;
			}
		}
	}
}

从冒泡排序的代码中可以看出,对于由n个数的成员来说,他们的比较次数是:(n-1) + (n-2) + (n-3) + ...+ 1  = n*(n-1)/2 = (n^2 - n)/2,因此其平均时间复杂度为O(n^2),最好时间复杂度为O(n).


选择排序,插入排序

将选择排序和插入排序放在一起,因为个人觉得选择排序和插入排序比价类似,但是又有所区别,选择排序是从为排序好的数据中选择出最小的数,假设为a,然后将排在已经排好序的后面;而插入排序是将某一数字,假设为b,从后往前依次与前面已经排好序的数相比较,直到找到比b小的数,将b插到此数的前面。

综上:选择排序是从未排序数据中找出最小数排在已排好序后面,插入排序是将数据插入到已排好序数组中。


插入排序代码如下:

void insertsort(int a[], int len)
{
	int i ,j;
	for(i = 0; i < len; i ++)
	{
		int temp = a[i];
		for(j = i-1; j >= 0; j --) //从已排序数组中最后一个数开始与i比较,找到最后一个比i大的数,将插入在该数前面
		{
			if (a[j] > temp )  
			{
				a[j+1] = a[j];
			}
			else 
				break;
		}
		a[j+1] = temp;
	}
}


选择排序代码如下:

void selectsort(int a[], int len)
{
	for (int i = 0; i < len; i++)
	{
		int k = i;   //使用k记录未排序数组中的下标
		for (int j = i; j < len; j++)
		{
			if (a[j] < a[k])
			{
				k = j;
			}
		}
		if (i != k)
		{
			int temp = a[i];
			a[i] = a[k];
			a[k] = temp;
		}
	}
}


从上面可以看出,选择排序和插入排序的平均时间复杂度都是O(n^2)


快速排序:

快速排序采用了分治法,即取一个参照数据,假设为a,将小于a的数据放在a的左边,将大于a的数据放在a的右边,然后分别对a左边和右边的数据采用同样的方式,举例:假设待排序数据为 5   3   6   4   9   7 ,选取5为参考数据,则经过一次快速排序后,应该变为4  3  5  6  9  7,此时小于5的数字被排在了左边,大于5的数字被排在了右边,然后分别再对 4  3  5  和  6  9  7  采用同样方法,直到排序完成。


快速排序代码如下:

int partition(int a[],int first, int last)
{
	int low = first;
	int high = last;
	int key = a[first]; //取第一个数为参考值

	while (low < high)
	{
		while (low < high && a[high] >= key)
			high --;
		a[low] = a[high];

		while(low < high && a[low] <= key)
			low ++;
		a[high] = a[low];
	}
	a[low] = key;

	return low;
}

void  quicksort(int a[],int first, int last)
{
	if (first < last)  //递归退出的条件,一定要有
	{
		int ret = partition(a, first, last);
		quicksort(a, first, ret);
		quicksort(a, ret+1, last);
	}
}

快速排序的平均时间复杂度是O(n*logn),最坏时间复杂度是O(n^2),空间复杂度是O(logn)


归并排序

归并排序是递归的将数组分成若干个已经排好序的微型数组,然后两两对若干个数组进行比较合并,比如 5  3  6  4  9   7,经过不断递归分为了 (5   3)(6  4)(9  7),进过合并排序后变为(3  5)(4  6)(7  9),然后再经过合并排序变成了(3  4  5  6)(7  9),经过最后一次合并变成了(3  4   5   6   7   9 )

归并排序代码如下:

//合并两个有序数组(其实是一个数组的两部分,以mid为分割),将小的数放进临时数组里
void mergesort_t::merge(int a[], int first, int mid, int last)
{
	int indexL = first;
	int indexR = mid + 1;
	int len = last - first + 1;
	int *temp = new int[len];
	int i = 0;

	while (indexL<=mid && indexR<=last)
	{
		if (a[indexL] <= a[indexR])
		{
			temp[i++] = a[indexL++];
		}
		if (a[indexL] > a[indexR])
		{
			temp[i++] = a[indexR++];
		}
	}

	while(indexL <= mid)
	{
		temp[i++] = a[indexL++];
	}

	while (indexR <= last)
	{
		temp[i++] = a[indexR++];
	}

	for (int j=0; j<i;j++)
	{
		a[first + j] = temp[j];
	}
	delete [] temp;
}

//先递归拆分数组,然后合并有序数组
void mergesort_t::mergesort(int a[], int first, int last)
{
	if (first < last)
	{
		int mid = (first + last)/2;
		mergesort(a, first, mid);
		mergesort(a, mid+1, last);
		merge(a, first, mid, last);
	}
}


归并排序的平均最好和最坏时间复杂度是O(nlogn),但是其空间复杂度是O(n).


堆排序

堆排序是将待排序数组化为最大堆(即堆顶为最大值),然后将堆顶(即最大值)与数组最后一个数字互换,然后重新化为最大堆,然后将堆顶与倒数第二个数字互换。。。以此循环,直到全部排序完成。


堆排序代码如下:

//创建某个父节点的最大堆
void heapsort_t::rootheapsort(int a[], int len, int index)
{
	//获取左右子节点
	int left = getleftchildindex(index);
	int right = getrightchildindex(index);
	int maxindex = index;

	//判断左右子节点与父节点的大小
	if (left < len &&  a[maxindex] < a[left])
	{
		maxindex = left;
	}
	if (right < len && a[maxindex] < a[right])
	{
		maxindex = right;
	}

	//如果当前最大的数不是父节点,则与当前父节点互换,且互换完成后要重新堆排序
	if (maxindex != index)
	{
		int temp = a[index];
		a[index] = a[maxindex];
		a[maxindex] = temp;
		rootheapsort(a, len, index);
	}
}

//创建某整个数组的最大堆
void heapsort_t::createMaxHeap(int a[], int len)
{
	int startIndex = getparentindex(len-1); //从第一个父节点开始对所有父节点执行堆化

	for (int i = startIndex; i >= 0; i--)
	{
		rootheapsort(a, len, i);
	}
}
//堆排序
void heapsort_t::heapsort(int a[], int len)
{
        //将目前的堆顶与最后一个元素互换,然后继续堆化剩余的,然后将再堆化后的堆顶变为倒数第二个元素,以此循环,直到整个数组遍历完。
	for (int i=len-1; i>=0; i--)
	{
		int temp = a[i];
		a[i] = a[0];
		a[0] = temp;
		rootheapsort(a,i,0);
	}
}
堆排序的时间复杂度是O(nlogn),空间复杂度是1.












评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值