三种最常用的排序方法及优缺点（冒泡排序、选择排序、插入排序），后续补充了四种排序（快排等）

一、冒泡排序法

        冒泡排序的基本思想是，通过重复地交换相邻两个元素的位置（如果它们处于错误的顺序），最终使得整个序列变成有序。具体做法是从数组的第一个元素开始，比较相邻的元素，如果前一个比后一个大（升序）就交换这两个元素，经过第一轮遍历后，最大的元素会被“冒”到数组的末尾；然后对剩下的元素再进行同样的操作，如此反复，直到没有任何一对数字需要交换位置。

def mp(li):
    for i in range(len(li)):
        for j in range(len(li)-1-i):
            if li[j] > li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]
    return li

二、选择排序法

        选择排序的思想是每一次从未排序的序列中找到最小（或最大）的元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。其实质是将待排序的序列分割成两部分，其中一部分记录已排序的元素，另一部分记录待排序的元素，每次从未排序元素中选取最小（或最大）的元素并将其放到已排序序列的末尾。

def xz(li):
    for i in range(len(li) - 1):
        min = i
        for j in range(i,len(li)):
            if li[min] > li[j]:
                min = j
        li[min], li[i] = li[i], li[min]
    return li

三、插入排序法

        插入排序的工作原理是通过构造一个有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。具体来说，插入排序是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。它是一种稳定的排序方法。算法流程是：首先假设数组的首个元素已经排序，然后取出下一个元素，在已排序的元素列表中从后向前扫描，找到相应的位置并插入，使插入后的元素仍然保持有序状态，重复这个过程，直到所有元素都排序完毕。

def cr(li):
    for i in range(1,len(li)):
        j = i - 1  #已排序列最后一个元素
        key = li[i]
        while j >=0:
            if li[j] > key:
                li[j + 1] = li[j]
                li[j] = key
            j -= 1
    return li

四、三种算法的优缺点

1. 冒泡排序：

   • 优点：实现简单，对小规模或者近乎有序的数据效率较高。
   • 缺点：时间复杂度较高，为O(n^2)，在处理大规模或者无序的数据时效率较低。由于它的交换次数较多，因此在实际应用中性能不高。

2. 选择排序：

   • 优点：实现也相对简单，无论最好还是最坏情况，时间复杂度都是O(n^2)，所以在数据量小或者部分有序的情况下表现还可以，且不需要额外的存储空间。
   • 缺点：但其效率仍不高，特别是对于大规模或者完全无序的数据，因为其每次都要查找剩余未排序部分的最小（或最大）元素，交换次数较多，性能不如其他高级排序算法。

3. 插入排序：

   • 优点：对于小规模数据和部分有序的数据有较好的效果，最好情况下（即输入数据已经是有序的）时间复杂度可以达到O(n)。并且在数据量较小或者局部较有序的情况下，插入排序效率较高。
   • 缺点：当数据规模较大，尤其是数据完全无序时，插入排序的时间复杂度仍然是O(n^2)，效率低。另外，插入排序需要移动元素，所以如果数组很大时，移动元素的开销也会增大。

总结起来，这三种排序算法都是简单的基础排序算法，适用于数据规模较小的情况，但对于大规模数据，他们都不是最优的选择，更高效的排序算法如快速排序、归并排序等更适合。

五、后续补充（2025.1.18），加入桶排序 、堆排序、快速排序、归并排序

1.桶排序

时间复杂度 ： O（n+C）C取决于选择什么排序
空间复杂度 : O（n+C）
稳定性 : 不确定，取决于选择什么排序

后面都用c++写的，语言学的杂

void  Mysort::bucket_sort(vector<int>& vec)
{
	int max = *max_element(vec.begin(), vec.end());
	int min = *min_element(vec.begin(), vec.end());
	int bucketNum = (max - min + 1) / vec.size() + 1;  //向上取整
	vector<vector<int>> Bucket(bucketNum);
	for (int i = 0; i < vec.size(); i++)
	{

		int index = (vec[i] - min + 1) / vec.size();  //第几桶
		Bucket[index].push_back(vec[i]);

	}
	for (int j = 0; j <Bucket.size(); j++)
	{
		sort(Bucket[j].begin(), Bucket[j].end());  //快速排序
	}
	vec.clear();
	for (int j = 0; j < Bucket.size(); j++)
	{
		for (int k = 0; k < Bucket[j].size(); k++)
			vec.push_back(Bucket[j][k]);
	}
}

2.堆排序  

时间复杂度 ：n*Logn
空间复杂度 : O（1）
稳定性 : 不稳定

void  Mysort::build_max_head(vector<int>& vec, int start, int end)
{
	int cur = start;
	int l = 2 * cur + 1;
	for (; l <= end; cur = l, l = 2 * cur + 1)
	{
		if (l < end && vec[l] < vec[l + 1]) l += 1;
		if (vec[l] > vec[cur]) swap(vec[l], vec[cur]);
		else  break;
	}
}

void  Mysort::head_sort(vector<int>& vec)
{
	for (int i = vec.size() / 2 - 1; i >= 0; i--)
	{
		build_max_head(vec, i, vec.size() - 1);
	}
	for (int i = vec.size()  - 1; i > 0; i--)
	{
		swap(vec[0], vec[i]);
		build_max_head(vec, 0, i - 1);
	}
}

3.归并排序  

时间复杂度 ：O（nlogn）
空间复杂度 : O（nlogn）
稳定性 : 稳定

void  Mysort::merge_up2down(vector<int>& vec,int l,int r)
{
	if (l >= r) return;
	int mid = l + (r - l) / 2;
	merge_up2down(vec, l, mid);
	merge_up2down(vec, mid+1,r);
	merge_sort(vec, l, mid, r);

}
void  Mysort::merge_sort(vector<int>& vec, int l, int mid, int r)
{
	int* p = new int[r - l + 1];
	int i = l, j = mid + 1, index = 0;
	while (i <= mid && j <= r)
	{
		if (vec[i] < vec[j]) p[index++] = vec[i++];
		else p[index++] = vec[j++];

	}
	while (i <= mid) p[index++] = vec[i++];
	while (j <= r) p[index++] = vec[j++];
	for (int i = 0; i < index; i++) vec[l + i] = p[i];
	delete[] p;
}

4.快速排序

递归/分治法  思想

void  Mysort::quick_sort(vector<int>& vec, int l, int r)
{
	if (l > r) return;
	int temp = vec[l];
	int i = l, j = r;
	while (i < j)
	{
		while (i<j && vec[j] > temp) j--;
		if (i < j) vec[i++] = vec[j];
		while (i<j && vec[i] < temp) i++;
		if (i < j) vec[j--] = vec[i];
	}
	vec[i] = temp;
	quick_sort(vec, l, i - 1);
	quick_sort(vec, i+1, r);
}