八大排序之堆排序和冒泡排序(2)

文章目录

    • 冒泡排序
        • 排序规则
        • 代码实现
        • 测试
        • 算法复杂度
    • 堆排序
        • 前置知识介绍
        • 算法思想
            • 算法步骤
            • 大顶堆调整规则
        • 代码实现
        • 测试
        • 算法复杂度分析

冒泡排序

排序规则

每一趟循环两两比较,大的向后挪动,最终最大值放在最后。假设现在有 n n n个数据,需要跑 n − 1 n-1 n1趟即可。

代码实现

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
void Bubble(int* arr, int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				Swap(&arr[j], &arr[j + 1]);
			}
		}
	}
	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
}

测试

八大排序之堆排序和冒泡排序(2)_第1张图片

算法复杂度

时间复杂度为 O ( n 2 ) O(n^2) O(n2) ,因为冒泡使用了双层for循环
空间负责度为 O ( 1 ) O(1) O(1),因为冒泡之使用了有限的几个变量,没有使用额外空间

堆排序

堆排序是指利用堆这种数据结构所涉及的一种排序算法,堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子节点的索引总是小于它的父节点。

前置知识介绍

二叉树:是指树中节点的度不大于2的有序树,是由一颗由根节点和两颗互补相交的,分别被称为左子树和右子树组成的非空树。
满二叉树:如果一个二叉树只有度为0的节点和度为2的节点,并且度为0的节点在同一层,则为满二叉树。
完全二叉树:深度为k,有n个节点的二叉树当且仅当每一个节点都与深度为k的满二叉树中编号1到n的节点一一对应时,称为完全二叉树。

节点:包含一个数据元素及若干指向子树的分支信息
节点的度:一个节点拥有子树的数目称为节点的度
孩子节点:节点的子树的根称为该节点的孩子
叶子节点: 没有子树的节点或者度为0 的节点

大顶堆:父节点的值大于孩子节点
小顶堆:父节点的值小于孩子节点

算法思想

原始数据:11,12,13,9,8,15,6
若要从小到大排序,则采用大顶堆
若要从大到小排序,则采用小顶堆
以下将此采用大顶堆示例

算法步骤

1.先将数据臆想成一个完全二叉树结构
八大排序之堆排序和冒泡排序(2)_第2张图片

2.将其调整为大顶堆
八大排序之堆排序和冒泡排序(2)_第3张图片
此时,我们可以发现根节点的值一定是整个数组中的最大的,并且我们知道根节点和最后一个节点的位置,我们将其位置进行交换,那么就相当于完成了冒泡排序的一次步骤。

3.将根节点的值和尾结点的值进行交换,并且将交换后尾结点的值剔除
八大排序之堆排序和冒泡排序(2)_第4张图片4.重复2,3操作,直到节点只剩下一个,则结束

大顶堆调整规则

从最后一个非叶子节点开始调整(从右向左,从下到上)
八大排序之堆排序和冒泡排序(2)_第5张图片调整后结果:
八大排序之堆排序和冒泡排序(2)_第6张图片

调整细节:
1.先将根节点的值取出来保存到tmp
2.需要找到当前空白节点的较大的孩子节点
3.较大的孩子节点和tmp去比较,如果比tmp大(子大于父),则将较大的这个孩子节点向上挪动
4.孩子节点向上挪动之后,不能直接将tmp插入到原先较大孩子的位置上,因为可以它可能还有孩子节点,而这个孩子节点的值也比tmp大
5.tmp插入时间?
八大排序之堆排序和冒泡排序(2)_第7张图片

1)触底(较大的孩子节点没有孩子)
八大排序之堆排序和冒泡排序(2)_第8张图片

2)较大的孩子节点的孩子节点值都小于tmp
八大排序之堆排序和冒泡排序(2)_第9张图片

代码实现

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
void heapAdjust(int *arr ,int start,int end)
{
	int tmp = arr[start];
	for (int i = start * 2 + 1; i <= end; i = start * 2 + 1) //start*2+1相当于start这个节点的左孩子
	{
		//i
		if (i<end && arr[i + 1]>arr[i])  //存在右孩子节点,并且右孩子节点值还大于左孩子节点
		{
			i++;  //此时,让i指向右孩子节点
		}

	//此时,i已经指向较大的孩子节点
		if (arr[i] > tmp)
		{
			arr[start] = arr[i];
			start = i;
		}
		else
		{
			break;  //退出for循环 ,触发情况2 
		}
	}
	arr[start] = tmp;
}
void HeapSort(int* arr, int len)
{
	//整体从最后一个非叶子节点开始由内到外调整一次
	//首先需要知道最后一个非叶子节点的下标
	for (int i = (len - 1 - 1) / 2; i >= 0; i--) //最后一个非叶子节点肯定是 最后一个叶子节点的父节点
	{
		heapAdjust(arr, i, len - 1); //调用一次调整函数
	}
	//此时,已经调整为大顶堆了
	//接下来,根节点和最后一个节点值进行交换,然后剔除掉尾结点
	for (int i = 0; i < len - 1; i++)
	{
		Swap(&arr[0], &arr[len - 1 - i]);
		heapAdjust(arr, 0, (len - 1 - i)-1);  //尾结点下标减一剔除循环
	}
}

测试

八大排序之堆排序和冒泡排序(2)_第10张图片

算法复杂度分析

时间复杂度: O ( n l o g n ) O(nlogn) O(nlogn),一次调整函数为 l o g n logn logn,调用了n次。
空间复杂度: O ( 1 ) O(1) O(1),因为没有用到额外空间

你可能感兴趣的:(数据结构,算法,数据结构)