数据结构~18.交换类排序

交换类排序

本文是上一篇文章的后续,详情点击该链接~

       在上一期我们学习了插入类排序的算法后,知道了排序的一些基本的原理。然而实际上排序除了插入类排序以外,还有很多种类的排序算法值得去学。比如,交换类排序,选择类排序,归并类排序还有基数类排序。而今天的交换类排序就有两种算法,它们分别是冒泡排序和快速排序。

冒泡排序

实现原理

       冒泡排序其实就是通过一系列的交换动作来达到排序的目的。打个比方,假如现在有两个元素,分别是A和B。A比B大,那么我们就要让A排到B的后面。这个时候我们可以定义一个新的变量来存储A的值,比如说我定义temp存储A的值,然后把B的值给A。这个时候A和B一样。由于刚刚A的值给了temp,所以我们现在把temp的值给B,那么这就实现了两个元素的交换了~

代码实现

void BubbleSort(int arr[],int n) {
     
	int i, j, flag, temp;
	for (i = n - 1; i >= 1; i--) {
     
		//flag 是用来标记是否发生了交换
		flag = 0;		
		for (j = 1; j <= i; j++) {
     
			if (arr[j - 1] > arr[j]) {
     
				temp = arr[j];
				arr[j] = arr[j - 1];
				arr[j - 1] = temp;
				//交换了,flag = 1,没交换就是0
				flag = 1;	
			}
		}
		//一趟排序过程中没有发生关键字的交换,那么就说明有序,则跳出
		if (flag == 0) {
     
			return;
		}
	}
}

算法复杂度

时间复杂度

       在最坏的情况下,当这个待排序的序列是逆序的,那么对于外层循环的每次执行,内层循环中的 if 语句就会一直成立,所以基本的操作执行次数就是 n - i。基本操作的总执行次数就是 ( n - 1 + 1 ) ( n - 1 ) / 2 = n ( n - 1 ) / 2。所以这个时间复杂度就是 O ( n² )

       那最好的情况呢?肯定就是这个序列全部都是有序的,那么内层循环的 if 就一直不成立。 基本上执行 n - 1 次后就会结束整个算法。 时间复杂度就是 O ( n )

空间复杂度

       刚刚的额外辅助空间只有一个temp,所以说空间复杂度就是 O ( 1 ) 了

快速排序

实现原理

       快速排序也是交换类排序,它是通过多次划分实现操作的排序。就拿升序举例子,这个执行流程基本可以概括为每一趟选择当前所有子序列中的一个元素作为枢轴，把子序列中比枢轴小的移到枢轴前边,然后比它大的移动到后边。等本趟所有子序列都被枢轴以刚刚的规则划分完成以后就会得到新的一组比较短的子序列,然后就会称为下一趟划分的初始序列集。

代码实现

void QuickeSort(int arr[], int left, int right) {
     
	int temp, i = left, j = right;
	if (left < right) {
     
		temp = arr[left];
		while (i < j) {
     
			//从右到左扫描,找到一个小于temp的元素
			while (j > i && arr[j] >= temp) {
     
				j--;
			}
			if (i < j) {
     
				//放在temp左边
				arr[i] = arr[j];
				i++;
			}
			//从左往右,找到大于temp的元素
			while (i < j && arr[i] < temp) {
     
				i++;
			}
			if (i < j) {
     
				//放temp右边
				arr[j] = arr[i];
				j--;
			}
		}
		//把temp放在最后的位置
		arr[i] = temp;
		//递归对左边排序
		QuickeSort(arr, left, i - 1);
		//递归对右边
		QuickeSort(arr, i + 1, right);
	}
}

算法复杂度

时间复杂度

       在最坏的情况下时间复杂度是O ( n² ),因为这个算法越接近有序,效率越低。那么最好的情况呢,就是O( nlog2n ),这个算法越接近无序,效率反而越高。平均下来,就是O( nlog2n )。

空间复杂度

       这个算法的空间复杂度是 O ( log2n ),因为刚刚用了递归,而递归则需要栈的辅助。所以它需要的辅助空间自然就比较大。