八大内部排序

最新推荐文章于 2022-08-15 14:14:48 发布

Stillsings

最新推荐文章于 2022-08-15 14:14:48 发布

阅读量2k

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构文章标签：数据结构排序算法算法八大排序内部排序

本文链接：https://blog.csdn.net/Listen_heart/article/details/108208203

数据结构专栏收录该内容

2 篇文章

订阅专栏

本文介绍了八大内部排序算法，包括冒泡排序、插入排序、希尔排序和快速排序等。每种排序都有其适用场景，例如冒泡排序在元素基本有序时效率较高，快速排序则在大规模数据下表现出优秀性能。通过理解这些排序算法，有助于选择合适的方法解决实际问题。

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

八大排序

前言

排序，就是重新排列表中的元素，使得表中元素满足按关键字有序的过程。

排序有许多种，常用的八大内部排序为冒泡排序、插入排序、选择排序、希尔排序、快速排序、归并排序、基数排序、堆排序

这几种排序没有绝对的优劣，每种排序都有他们适用范围

一、冒泡排序

冒泡排序每一趟排序可以确定一个元素的最终位置，若一次扫描并没有元素进行交换，则说明表已有序。

void bubbleSort(ElemType a[], int n){
	for(int i = 0; i < n - 1; i++){
		bool flag = false;
		for(int j = n - 1; j > i; j--){
			if(a[j] < a[j - 1]){
				swap(a[j], a[j - 1]);
				flag = true;
			}
		}
		if(flag == false){
			return;
		}
	} 
}

冒泡排序的性能分析：空间效率为O(1)，最坏时间复杂度为O( $n^2$ )，平均时间复杂度为O( $n^2$ )。

二、插入排序

插入排序的基本思想是将一个未排序的表，按照关键字大小插入到前面已经排好序的子序列（表）中，直到表中所有元素插入完成。

void insertSort(ElemType a[], int n){
    int i, j;
    for(int i = 2; i <= n; i++){
        if(a[i] < a[i-1]){
            a[0] = a[i];
            for(j = i - 1; a[0] < a[j]; --j)
                a[j+1] = a[j]
            a[j+1] = a[0];
        }
    }
}

性能分析，插入排序的空间复杂度为O(1)，时间复杂度为O( $n^2$ )

三、希尔排序

希尔排序的基本思想是先将待排序的表分割成若干个特殊子表，每个子表的元素在主表中间隔n个元素，并将间隔量称为增量，然后对各个子表进行插入排序，当整个表中的元素基本有序，再对全体记录进行一次插入排序

void shellSort(ElemType a[], int n){
	for(int dk = n/2; dk >= 1; dk = dk/2){
		for(int i = dk + 1; i <= n; i++){
			if(a[i] < a[i - dk]){
				a[0] = a[i];
				for(int j = i - dk; j > 0 && a[0] < a[j]; j -= dk){
					a[j+dk] = a[j];
				}
				a[j+dk] = a[0];	
			}
		}
	}
}

性能分析：空间复杂度为O(1)，时间复杂度为O( $n^{1.3}$ )，最坏情况为O( $n^2$ )

四、快速排序

快速排序的基本思想是分治，在待排序的表中随机选取一个元素pivot作为枢纽（基准），经过一次排序后，枢纽左边的元素均小于枢纽，枢纽右边的元素均大于枢纽，即枢纽确定其在有序表的最终位置，这样的一次过程称为一趟快排，或叫一次划分。

int partition(ElemType a[], int lo, int hi){
	int pivot = a[lo];
	while(lo < hi){
		while(lo < hi && a[hi] >= pivot) --hi;
		a[lo] = a[hi];
		while(lo < hi && a[lo] <= pivot) ++lo;
		a[hi] = a[lo];
	}
	a[lo] = pivot;
	return lo;
}
void quickSort(ElemType a[], int lo, int hi){
	if(lo < hi){
		int pivot = partition(a, lo, hi);
		quickSort(a, lo, pivot - 1);
		quickSort(a, pivot + 1, hi);
	} 
}

性能分析：空间效率，快排递归需要借助递归工作栈来保存每层递归的信息，其容量和递归的最大深度一致。时间效率，最好情况 $O(log_{2}n)$ ，快排的最坏情况发生在两个区域分别包含n-1个元素和0个元素时，这种极大程度的不对称性若发生在每次递归中，即对应的表基本有序或基本逆序，则最坏情况的时间复杂度为 $O(n^2)$ 。