当前位置：首页 > article >正文

【数据结构】手撕排序NO.1

article 2024/9/21 20:51:26

在这里插入图片描述
🔥博客主页： 小羊失眠啦.
🎥系列专栏：《C语言》 《数据结构》 《Linux》《Cpolar》
❤️感谢大家点赞👍收藏⭐评论✍️

在这里插入图片描述

文章目录

一、排序的概念及其运用
- 1.1 排序的概念
- 1.2 常见的算法排序
二、冒泡排序
三、直接插入排序
四、希尔排序
五、选择排序

一、排序的概念及其运用

1.1 排序的概念

排序：所谓排序就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。

内部排序：数据元素全部放在内存中的排序。

外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

1.2 常见的算法排序

排序算法分为比较类排序和非比较类排序，如下图所示：

在这里插入图片描述

二、冒泡排序

思想 : 在一个序列中，每次对序列中的相邻记录的键值大小进行比较，将较大(升序)或较小(降序)的记录向后移动。如此循环，大/小的记录会慢慢“浮”到序列的后端，整个过程就像是冒泡一样，顾称之为冒泡排序。
冒泡过程：以下是对某个序列进行冒泡排序的过程

在这里插入图片描述

可以看出，对于上面具有5个元素的无序数组，我们通过4趟的冒泡后就将其变为有序数组，每一趟冒泡后都可以使最大的数沉底。

动图演示：我们可以通过一下动图感受一下冒泡两两比较的过程：

循环控制：很明显，我们需要两层循环来控制冒泡排序的过程。内层循环控制当前趟的数据交换，外层循环控制冒泡排序的趟数。
外层循环结束条件：由于每一趟结束后都有一个数冒到序列后端，因此对于N个数的序列来说，一共需要N-1趟(只剩一个数不需要冒泡)。

for (int i = 0; i < n - 1; i++) //外层循环，N-1趟
{
     ; 
}

内层循环结束条件：内层循环用于数据的比较。已知N个数据共需比较N-1次，由于每一趟结束后就有数据到正确的位置，下一趟需要比较的数据个数就会少1，因此每趟的比较次数随着趟数的增加呈递减趋势，初始为N-1次。

for (int i = 0; i < n - 1; i++) //外层循环，N-1趟
{
	for (int j = 0; j < n - 1 - i; j++) //内层循环，次数随趟数增加而递减，初始为N-1
	{
           ;
	}
}

完整代码：

void swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

void BubblingSort(int* a, int n)
{

	for (int i = 0; i < n - 1; i++) //外层循环，N-1趟
	{
		for (int j = 0; j < n - 1 - i; j++) //内层循环，次数随趟数增加而递减，初始为N-1
		{
			if (a[j] > a[j + 1]) //升序排列，较大的往后移
			{
				swap(&a[j], &a[j + 1]); //交换
			}
		}
	}
}

改进优化：上面的代码还存在着改进空间，我们来看下面两个情景：

在这里插入图片描述

对于情境1，我们只需一趟冒泡即可让数组有序，而如果按照上面的代码，我们依旧要进行4趟的冒泡，即有三趟是无效的。

而情境2就更夸张了，数组已经有序，我们却傻乎乎的做了4趟无效冒泡。无疑是非常浪费时间的。

考虑到这些情况，我们提出了优化方案：在每趟结束后判断一下当前趟是否发生了元素交换，如果没有，则说明序列已经有序了，及时止损，反之继续。优化后的代码如下：
void swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

void BubblingSort(int* a, int n)
{

	for (int i = 0; i < n - 1; i++) //外层循环，N-1趟
	{
		int flag = 0;
		for (int j = 0; j < n - 1 - i; j++) //内层循环，次数随趟数增加而递减，初始为N-1
		{
			if (a[j] > a[j + 1]) //升序排列，较大的往后移
			{
				swap(&a[j], &a[j + 1]); //交换
				flag = 1;
			}
		}
		if (flag == 0)
			break;
	}
}

时间/空间复杂度：结合上面的图片和代码我们可以看出，总共N-1趟，每趟N-1，N-2…次比较，共比较 (N-1) + (N-2) + (N-3) + (N-4) + (N-5) + … + 1次，时间复杂度为O(N^2)；而由于没有额外的辅助空间，空间复杂度为O(1)。
稳定性分析：由于我们是将较大的或较小的进行交换，当两个数相等时并不会进行交换，因而不会改变相同元素的先后次序，所以冒泡排序是稳定的排序。

三、直接插入排序

思想：把待排序的数据按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的数据插入完为止，得到一个新的有序序列。实际中我们玩扑克牌时，就用了插入排序的思想。

注意：数组中除了第一个元素（默认有序），其余所有元素都看作待插入数据。

排序步骤 ：

将有序数据的最后一个元素的下标记为 end，则第一个待插入元素的下标为 end+1，记作 tmp
将 tmp 与有序数据从后向前依次比较
如果 tmp < a[end]，就将 a[end] 向后移动，end–，再去找下一位进行比较
直到 tmp > a[end] 或者 end < 0，将 tmp 插入到 end+1 的位置
重复步骤，就可以实现排序

代码实现：

void InsertSort(int* a, int n)
{
    for (int i = 0; i < n - 1; i++)
    {
        int end = i;
        int tmp = a[end + 1];
        while (end >= 0)
        {
            if (tmp < a[end])
            {
                a[end + 1] = a[end];
            }
            else
            {
                break;
            }
            --end;
        }
        a[end + 1] = tmp;
    }
}

在这里插入图片描述

时间/空间复杂度：结合上面的图片和代码我们可以看出时间复杂度为O(N^2)；由于没有额外的辅助空间，空间复杂度为O(1)。
稳定性分析：是稳定的排序。

四、希尔排序

思想：

先选定一个整数，把待排序文件中所有记录分成个组，所有距离为3的数据分在同一组内，并对每一组内的数据进行排序。然后，重复上述分组和排序的工作。当距离=1时，所有数据在统一组内排好序。

希尔排序分为两步：
1. 预排序
2. 直接插入排序
当元素集合越接近有序，直接插入排序的效率很高，希尔排序就是通过预排序使元素集合接近有序，再进行直接插入排序，这样大大提高了效率。

排序步骤:

选取一个合适的 gap 作为间距
将间距为 gap 的数据分为一组，分成 gap 组
每一组数据都进行直接插入排序，使数据接近有序
不断缩小间距，当 gap==1 时，数据进行直接插入排序，实现排序

代码实现：

void ShellSort(int* a, int n)
{
    int gap = n;
    while (gap > 1)
    {
        gap = gap / 3 + 1;
        for (int i = 0; i < n - gap; i++)
        {
            int end = i;
            int tmp = a[end + gap];
            while (end >= 0)
            {
                if (tmp < a[end])
                {
                    a[end + gap] = a[end];
                    end -= gap;
                }
                else
                {
                    break;
                }
            }
            a[end + gap] = tmp;
        }
    }
}

特点:
1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算。
4. 空间复杂度：O(1)
5. 稳定性：不稳定

五、选择排序

思想 : 每一次从待排序的数据元素中选出最小(升序)或最大(降序)的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
**选择过程：**以下是对某个序列进行选择排序的过程：

在这里插入图片描述

动图演示：我们一样通过动图感受一下选择排序的过程：

循环控制：类似的，我们需要两层循环来控制选择排序的过程。内层循环遍历序列找出最大/最小值，外层循环控制选择的次数。
外层循环结束条件：每一次遍历完都可以选出一个数换到起始位置，一共N个数，故要选N-1次(最后一个数不需要选择)

for (int i = 0; i < n-1; i++) //外层循环，共要选择n-1次
{
      ;
}

内层循环结束条件：内层循环通过比较进行选数，一开始N个数需要比较N-1次，然后每趟结束后下一次选择的起始位置就往后移动一位，比较次数减1

for (int i = 0; i < n-1; i++) //外层循环，共选择n-1次
{
	for (int j = i + 1; j < n; j++) //内层循环，起始位置开始向后进行比较，选最小值
	{
           ;
	}
}

完整代码：

void swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}


void SelectSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++) //外层循环，共选择n-1次
	{
		int mini = i; //记录最小值的下标，初始为第一个数下标
		for (int j = i + 1; j < n; j++) //内层循环，起始位置开始向后进行比较，选最小值
		{
			if (a[mini] > a[j]) //比最小值小，交换下标
			{
				mini = j;
			}
		}
		swap(&a[mini], &a[i]); //将最小值与起始位置的数据互换
	}
}