八大排序总结

^花九九

已于 2023-09-20 21:46:17 修改

阅读量65

点赞数

文章标签：排序算法算法数据结构

于 2023-09-20 19:06:17 首次发布

本文链接：https://blog.csdn.net/huaooo1/article/details/133070831

版权

1.插入排序

思想：插入排序将整个数列划分为已排序和未排序两个区间，初始情况下，已排序区间只有一个元素，那就是数列的第一个元素，然后重复取未排序区间中的元素逐个插入到已排序区间中
（从后向前扫描），直至未排序区间元素数量为0。那么时间复杂度就是O(n^2)。

//插入排序
void InsertSort(vector<int>& s) {
	for (int i = 0; i < s.size(); ++i) {
		for (int j = i; j > 0; --j) {
			if (s[j] < s[j - 1]) {
				swap(s[j], s[j - 1]);
			}
			else { 
				break;
			}
		}

	}
}

2.希尔排序

思想：把数组分割成若干个小组，间隔gap大小，然后对每一个小组分别进行插入排序。每一轮减小间隔大小，并且进行排序，保证有序。当h=1时，则数组排序完成。O(n^1.3-n^2),不稳定


//希尔排序
void ShellSort(vector<int>& s) {
	int gap = s.size();
	while (gap > 1) {
		gap = gap / 3 + 1;
		for (int i = gap; i < s.size(); ++i) {
			for (int j = i; j >= gap; j -= gap) {
				if (s[j] < s[j - gap]) {
					swap(s[j], s[j - gap]);
				}
				else {
					break;
				}
			}
		}

	}
}

3.选择排序

思想：找到最小的元素，和数组第一个数交换位置，找到第二小的元素，和数组第二个数交换位置...直到最后一个元素，排序完成。O(n^2)，不稳定

//选择排序
void SelectSort(vector<int>& s) {
	for (int i = 0; i < s.size(); ++i) {
		int num = i;//记录最小值的位置
		for (int j = i + 1; j < s.size(); ++j) {
			if (s[j] < s[num]) {
				num = j;
			}
			
		}
		if (i != num) {
			swap(s[i], s[num]);
		}
	}
}

4.堆排序

思想：初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。

输出堆顶元素后，对剩余n-1元素重新建成堆的调整过程。

调整小顶堆的方法：

1）设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶（（最后一个元素与堆顶进行交换），堆被破坏，其原因仅是根结点不满足堆的性质。

2）将根结点与左、右子树中较小元素的进行交换。

3）若与左子树交换：如果左子树堆被破坏，即左子树的根结点不满足堆的性质，则重复方法

4）若与右子树交换，如果右子树堆被破坏，即右子树的根结点不满足堆的性质。则重复方法

5）继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，堆被建成。

讨论对n 个元素初始建堆的过程。
建堆方法：对初始序列建堆的过程，就是一个反复进行筛选的过程。

1）n 个结点的完全二叉树，则最后一个结点是第

个结点的子树。

2）筛选从第

个结点为根的子树开始，该子树成为堆。

3）之后向前依次对各结点为根的子树进行筛选，使之成为堆，直到根结点。


void Heap_Adjust(vector<int>& s, int head, int len) {
	int tmp = s[head];
	int child = 2 * head + 1;//左孩子
	while (child < len) {
		if (child + 1 < len && s[child] < s[child + 1]) {//右孩子大于左孩子(找到比当前待调节点大的孩子节点)

			++child;
		}
		if (s[head] < s[child]) {//较大的子节点大于父节点
			s[head] = s[child];//将较大的子节点向上移动，替换父节点
			head = child;//重新设置head,（待调整的节点）
			child = 2 * head + 1;

		}
		else {//如果待调整的节点大于他的左右孩子，则不用调整直接跳出
			break;
		}
		s[head] = tmp;//将待调整节点放在比他大的孩子节点位置上
	}
}
void Build_Heap(vector<int>& s, int num) {
	for (int i = (num - 1) / 2; i >= 0; --i) {
		Heap_Adjust(s, i, num);
	}
}
//堆排
void Heapsort(vector<int>& s) {
	int n = s.size();
	Build_Heap(s, n);//创建堆
	//从最后一个元素开始对序列进行调整
	for (int i = n - 1; i > 0; --i) {
		swap(s[i], s[0]);//交换堆顶元素和堆最后
		Heap_Adjust(s, 0, i);//调整
	}

}

5.冒泡排序

思想：比较相邻的元素。如果第一个比第二个大，就交换它们两个；

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

O(n^2)

//冒泡排序
void BuleSort(vector<int> &s){
	for (int i = 1; i < s.size(); ++i) {
		for (int j = 0; j < s.size() - i; ++j) {
			if (s[j] > s[j + 1]) {
				swap(s[j], s[j + 1]);
			}
		}
	}
}

冒泡排序优化：

加入一标志性变量exchange，用于标志某一趟排序过程中是否有数据交换，如果进行某一趟排序时并没有进行数据交换，则说明数据已经按要求排列好，可立即结束排序，避免不必要的比较过程。本文再提供以下两种改进算法：

方法一：设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

//冒泡排序优化
void Bule_sort1(vector<int>& s){
	int exchange = s.size() - 1;
	while (exchange > 0) {
		int pos = 0;
		for (int i = 0; i < exchange; ++i) {
			if (s[i] > s[i + 1]) {
				pos = i;
				int tmp = s[i];
				s[i] = s[i + 1];
				s[i + 1] = tmp;
			}
		}
		exchange = pos;
	}
}

方法二：传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

6.快排

思想：从数组中选一个数做为基准值，一般选第一个数，或者最后一个数。采用双指针(头尾两端)遍历，从左往右找到比基准值大的第一个数，从右往左找到比基准值小的第一个数，交换两数位置，直到头尾指针相等或头指针大于尾指针，把基准值与头指针的数交换。这样一轮之后，左边的数就比基准值小，右边的数就比基准值大。O(NlogN）

八大排序-快排及优化_^花九九的博客-CSDN博客

7.归并排序

思想：所以对n 个元素的待排序列，每个元素可看成1 个有序子表。对子表两两合并生成n/2个子表，所得子表除最后一个子表长度可能为1 外，其余子表长度均为2。再进行两两合并，直到生成n 个元素按关键码有序的表。


//归并排序
void Mer_Sort(vector<int>& s, int begin, int end, vector<int>& arr) {
	if (begin >= end)	return;
	int mid = (begin + end) >> 1;
	Mer_Sort(s, begin, mid, arr);
	Mer_Sort(s, mid + 1, end, arr);
	int left = begin;
	int right = mid + 1;
	int tmp = begin;
	while (left <= mid && right <= end) {
		if (s[left] < s[right]){
			arr[tmp++] = s[left++];
		}
		else {
			arr[tmp++] = s[right++];
		}
	}
	while (left <= mid) {
		arr[tmp++] = s[left++];
	}
	while (right <= end) {
		arr[tmp++] = s[right++];
	}
	for (int i = begin; i <= end; ++i) {
		s[i] = arr[i];
	}
}

8.基数排序

思想：将所有待比较树脂统一为统一位数长度，接着从最低位开始，依次进行排序。
1. 按照个位数进行排序。
2. 按照十位数进行排序。
3. 按照百位数进行排序。
排序后，数列就变成了一个有序序列。

进行多次的桶式排序。


//基数排序
//求数据的最大位数
int maxbit(vector<int>& s, int num) {
	int maxdata = s[0];
	for (int i = 1; i < num; ++i) {
		if (maxdata < s[i]) {
			maxdata = s[i];
		}
	}
	int d = 1;
	int p = 10;
	while (maxdata >= p) {
		maxdata /= 10;
		++d;
	}
	return d;
}

void Radix_Sort(vector<int>& s) {
	int num = s.size();
	int d = maxbit(s, num);
	vector<int> tmp(num, 0);
	vector<int> count(10, 0);//计数器
	int i, j, k;
	int radix = 1;
	for (int i = 1; i <= d; ++i) {
		for (j = 0; j < 10; ++j) {
			count[j] = 0;//每次分配前清空计数器
		}
		for (int j = 0; j < num; ++j) {
			k = (s[j] / radix) % 10;//统计每个桶中的记录数
			count[k] ++;
		}
		for (j = 1; j < 10; ++j) {
			count[j] = count[j - 1] + count[j];//将tmp的位置依次分配给每个桶
		}
		for (j = num - 1; j >= 0; --j) {
			k = (s[j] / radix) % 10;
			tmp[count[k] - 1] = s[j];
			count[k] --;
		}
		for (j = 0; j < num; ++j) {
			s[j] = tmp[j];
		}
		radix = radix * 10;
	}
}

总结

^花九九

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
八大排序总结

目录1.插入排序2.希尔排序3.选择排序4.堆排序5.冒泡排序冒泡排序优化6.快排7.归并排序8.基数排序总结思想：插入排序将整个数列划分为已排序和未排序两个区间，初始情况下，已排序区间只有一个元素，那就是数列的第一个元素，然后重复取未排序区间中的元素逐个插入到已排序区间中（从后向前扫描），直至未排序区间元素数量为0。那么时间复杂度就是O(n^2)。2.希尔排序思想：把数组分割成若干个小组，间隔gap大小，然后对每一个小组分别进行插入排序。每一轮减小间隔大小，并且
复制链接

扫一扫