2024年大数据最全【数据结构】手撕八大排序算法(2)，2024年最新整理出大数据开发逆向系列学习进阶视频

最新推荐文章于 2024-07-10 15:16:59 发布

2401_84615578

最新推荐文章于 2024-07-10 15:16:59 发布

阅读量959

点赞数 25

分类专栏：程序员文章标签：大数据数据结构排序算法

本文链接：https://blog.csdn.net/2401_84615578/article/details/138459061

版权

程序员专栏收录该内容

51 篇文章 0 订阅

订阅专栏

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

平均时间复杂度：O ( N^ 1.3 )

2.3选择排序：

动图演示：

思路：

设两个下标begin和end，begin初始化为0，end初始化为n-1

设置最大值和最小值的下标让他们指向begin

当a[i]的值比a[begin]小，更新min的值，当a[i]的值比a[begin]大，更新max的值

循环走完后确认了最小值的下标，将a[begin]和a[min]进行交换，以及a[end]和a[max交换]

极端情况：

当最大值为数组的第一个时，max=min

时间复杂度：O(N^2) 空间复杂度：O(1)

void SelectSort(int* a, int n)
{
	int begin = 0;
	int end = n - 1;
	while (begin < end)
	{
		int mini = begin;
		int maxi = begin;
		for (int i = begin+1; i <=end; i++)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}
		Swap(&a[mini], &a[begin]);
		if (maxi == begin)
		{
			maxi = mini;
		}
		Swap(&a[maxi], &a[end]);
		begin++;
		end--;
	}
}

2.4堆排序

堆排序：（以小堆为例）
堆的分类：

1.升序or降序
2.大堆or小堆

void test2()
{//堆排序
	int array[] = { 27,15,19,18,28,34,65,49,25,37 };
	Heapsort(array, sizeof(array) / sizeof(array[0]));
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");
 
}

Heapsort函数（堆排序）：
int array[] = { 27,15,19,18,28,34,65,49,25,37 };

需将这个数组进行大堆排列，分为两种调整形式：向上调整和向下调整。

向上调整和向下调整的思想可以参考我的例外一篇博客：http://t.csdn.cn/UD52X

void Ajustup(HPDataType*a, int child)
{//N*logN
    assert(a);
    //int child = n - 1;
    while (child > 0)
    {
        int parent = (child - 1) / 2;
        if (a[child] > a[parent])
        {
            Swap(&a[child], &a[parent]);
            child = parent;
        }
        else
        {
            break;
        }
    }
}
void Ajustdown(HPDataType* a, int n,int parent)
{//O(N)
    assert(a);
    int child = 2 * parent+1;
    while (child<n)
    {
        if (child + 1 < n && a[child] < a[child + 1])//  <假设左子树大
        {
            child++;
        }
        if (a[child] > a[parent])//>大堆，<为小堆
        {
            Swap(&a[child], &a[parent]);
            parent = child;
            child = child * 2 + 1;
        }
        else
        {
            break;
        }
    }
}

向上调整和向下调整具体的时间复杂度是多少呢？

向下调整具体的时间复杂度：

假设树高为h

第h层，有2^(h-1）个节点，需要向下调整0次（直接不算，从第h-1层开始算）。

第h-1层，有2^（h-2）个节点，需要向下调整1层。

第h-2层，有2^（h-3）个节点，需要向下调整2层。

…

第4层，有2^3个节点，需要向下调整h-4层。

第3层，有2^2个节点，需要向下调整h-3层。

第2层，有2^1个节点，需要向下调整h-2层。

第1层，有2^0个节点，需要向下调整h-1层。

当h高的次数，最多调整层数为：

F（h）=2^{0*（h-1）+2}1*(h-2)+2^{2*(h-3)+…+2}(h-3)*2+2^(h-2)*1+2(h-1)*0 ——①

2*F（h）=2^{1*（h-1）+2}2*(h-2)+2^{3*(h-3)+…+2}(h-2)*2+2^(h-1)*1+2(h)*0 ——②

有错位相减②-①可得：

F（h）=-2^{0*（h-1）+2}1+2^2+…+2(h-2)+2^(h-1)

F（h）=2^h-1-h ——③

当树高为h时，节点总个数N为：

N=2⁰⁺²1+…+2^（h-2）+2（h-1）

N=2^h-1 ——④

有④可得：h=log（N+1） ——⑤

综合③④⑤可得：

F（N）=N-log（N+1）

因此时间复杂度为O（N）

向上调整具体的时间复杂度：
在一层，需要向上调整0次

第二层，向上调整1次

第三层，向上调整2次

…

第h-1层，向上调整h-2次

第h层，向上调整h-1次

F（h）=2^1*1+22*2+…+2^(h-1)*(h-1)。

由错位相减可得：

F(N)=2N(1-log(N+1))。

时间复杂度为O（N*logN）
如何实现堆排序
显然向下调整优于向上调整。

先利用Ajustdown排序好数组，然后再用交换Ajustdown实现小堆。

void Heapsort(int*a,int n)//堆排序
{//向上调整
	for (int i = 1; i <n; i++)
	{
		Ajustup(a, i);
	}
	//向下调整
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		Ajustdown(a, n, i);
	}
	int end = n - 1;
	while (end>0)
	{
		Swap(&a[0], &a[end]);
		Ajustdown(a, end, 0);
		end--;
	}
	//N*logN
}
void test2()
{//堆排序
	int array[] = { 27,15,19,18,28,34,65,49,25,37 };
	Heapsort(array, sizeof(array) / sizeof(array[0]));
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");
 
}

2.5冒泡排序

动图演示：

代码：

void BubbleSort(int* a, int n)
{
	for (int j = 0; j < n; j++)
	{
		for (int i = 1; i < n - j; i++)
		{
			if (a[i] < a[i - 1])
			{
				Swap(&a[i],& a[i - 1]);
			}
		}
	}
}

时间复杂度：O(N^2) 空间复杂度：O(1)

2.6快速排序：

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

快速排序有三种写法：

1.hoare版本

2.挖坑法

3.前后指针法

以及优化：

1.三数取中

2.6.1hoare版本（递归版本）

动图演示：

hoare版本思路：

单趟排序，key一般选最左边或者最右边

当key为最左边，右边找小，左边找大，然后交换继续，相遇停止，相遇的值跟key交换

当key为最右边相反

当左区间有序，右区间有序那整体就ok了，如果左右区间不有序，左右区间就是单趟的子问题

当区间只有一个值，就不排了，返回

问题：为什么是key为最左边时，右边先走，最右边做key时，左边先走

answer：左边做key，右边先走，可以保证相遇位置比key要小

此时有两种情况：

1.相遇，left是停着(一定>=key)，right向后走，相遇的位置是left的位置

2.相遇，right是停着（一定<=key），left向前走，相遇的位置是right的位置

单趟有两个意义

1.分割出左右区间，左比key小，右比key大

2.key到了正确位置（排序后的最终位置）

key以后不用变了，到了正确位置

代码：

int Partsort1(int* a, int begin, int end)
{//hoare版本
	int mid = GetMidIndex(a, begin, end);
	Swap(&a[mid], &a[begin]);
	int left = begin;
	int right = end;
	int keyi = begin;
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[left], &a[keyi]);
	keyi = left;
	return keyi;
}
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
	if (end-begin+1 < 10)
	{
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		int keyi=Partsort1(a, begin, end);
		//int keyi=Partsort2(a, begin, end);

		//int keyi = Partsort3(a, begin, end);

		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
}

时间复杂度:O(NlogN)

2.6.2三数取中

每次排序都会将数组分为三个部分：

【left-key-1】【key】【keyi+1-right】

在理想情况下，我们每次进行完单趟排序后，key的左序列与右序列的长度都相同：

若每趟排序所选的key都正好是该序列的中间值，即单趟排序结束后key位于序列正中间，那么快速排序的时间复杂度就是O(NlogN)。

但事实上可能会遇到极端情况：就是我们每次取到的都是最大值或者最小值，那么快排的时间复杂度达到最低O（N^2）

可以看到，这种情况下，快速排序的时间复杂度退化为O(N^2)。其实，对快速排序效率影响最大的就是选取的key，若选取的key越接近中间位置，则则效率越高。

为了避免这种极端情况的发生，于是出现了三数取中：
三数取中，当中的三数指的是：最左边的数、最右边的数以及中间位置的数。三数取中就是取这三个数当中，值的大小居中的那个数作为该趟排序的key。这就确保了我们所选取的数不会是序列中的最大或是最小值了。

代码：

int GetMidIndex(int* a, int begin, int end)
{
	int mid = (begin + end) / 2;
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
		{
			return mid;
		}
		else if (a[begin] > a[end])//a[mid]>a[end]的前提下
		{
			return begin;
		}
		else//a[mid]>a[end]&&a[begin] < a[end]的前提下
		{
			return end;
		}
	}
	else//a[begin] > a[mid]
	{
		if (a[end] < a[mid])
		{
			return mid;
		}
		else if (a[begin] > a[end])//a[end] > a[mid]
		{
			return end;
		}
		else//a[end] > a[mid]&&a[begin] < a[end]
		{
			return begin;
		}
	}
}

2.6.3挖坑法

动图演示：

思路：

将一开始的left保存起来，然后左边空出来一个坑，右边先走，右找大，然后将右边的值的数据填进去，找到的位为坑，左边找小将右边的坑填进去，最后一定会在坑的位置相遇

代码：

int Partsort2(int* a, int begin, int end)
{//挖坑法
	int mid = GetMidIndex(a, begin, end);
	Swap(&a[mid], &a[begin]);
	int left = begin;
	int right = end;
	int keyi = a[left];
	int hole = left;

	while (left < right)
	{
		while (left < right && a[right] >= keyi)
		{
			right--;
		}
		a[hole] = a[right];
		hole = right;
		while (left < right && a[left] <= keyi)
		{
			left++;
		}
	    a[hole]=a[left];
		hole = left;
	}
	a[hole] = keyi;
	keyi = left;
	return hole;
}
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
	if (end-begin+1 < 10)
	{
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		//int keyi=Partsort1(a, begin, end);
		int keyi=Partsort2(a, begin, end);

		//int keyi = Partsort3(a, begin, end);

		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
}

时间复杂度:O(NlogN)

2.6.4前后指针法：

动图演示：

思路：

1、cur找比key小，找到后停下来
2、++prev, 交换prev位置和cur位置的值
代码：

int Partsort3(int* a, int begin, int end)
{
	int  prev = begin;
	int cur = begin + 1;
	int keyi = begin;
	while (cur<=end)
	{
		/*if (a[cur] < a[keyi])
		{
			Swap(&a[++prev], &a[cur]);
		}*/
		if (a[cur] < a[keyi]&&++prev!=cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		cur++;
	}
	Swap(&a[prev], &a[keyi]);
	keyi = prev;
	return keyi;
}
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
	if (end-begin+1 < 10)
	{
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		/*int keyi=Partsort1(a, begin, end);
		int keyi=Partsort2(a, begin, end);*/

		int keyi = Partsort3(a, begin, end);

		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
}

时间复杂度:O(NlogN)

2.6.5非递归写法：

思路：

通过非递归的方式实现递归的情况的话，递归从底层是先排左边再排右边因此类推，因此写非递归我们从顶层到底层就需要反过来。

借助栈的内存结构让先入的后出，所以要先压begin再压end，取出来的话就是先出右再出左

再先排右边再排左边。

代码：

void QuickSortNonR(int* a, int begin, int end)
{//非递归
	ST st;
	StackInit(&st);
	StackPush(&st, begin);
	StackPush(&st, end);
	while (!StackEmpty(&st))
	{
		int right = StackTop(&st);
		StackPop(&st);
		int left = StackTop(&st);
		StackPop(&st);
		int keyi = Partsort3(a, left, right);//单趟排序
		if (keyi + 1 < right)
		{
			StackPush(&st, keyi+1);
			StackPush(&st, right);
		}
		if (left < keyi-1)
		{
			StackPush(&st, left);
			StackPush(&st, keyi - 1);
		}
	}
	StackDestory(&st);
}

2.7归并排序

2.7.1递归写法：

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

tackPush(&st, end);
while (!StackEmpty(&st))
{
int right = StackTop(&st);
StackPop(&st);
int left = StackTop(&st);
StackPop(&st);
int keyi = Partsort3(a, left, right);//单趟排序
if (keyi + 1 < right)
{
StackPush(&st, keyi+1);
StackPush(&st, right);
}
if (left < keyi-1)
{
StackPush(&st, left);
StackPush(&st, keyi - 1);
}
}
StackDestory(&st);
}




---


### 2.7归并排序


#### 2.7.1递归写法：



[外链图片转存中...(img-5GzGmEZs-1714868077513)]
[外链图片转存中...(img-bMMNH0wv-1714868077513)]
[外链图片转存中...(img-p9EkvcBH-1714868077513)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**

2401_84615578

关注

25
点赞
踩
15

收藏

觉得还不错? 一键收藏
1
评论
2024年大数据最全【数据结构】手撕八大排序算法(2)，2024年最新整理出大数据开发逆向系列学习进阶视频

answer：左边做key，右边先走，可以保证相遇位置比key要小此时有两种情况：1.相遇，left是停着(一定>=key)，right向后走，相遇的位置是left的位置2.相遇，right是停着（一定
复制链接

扫一扫