数据结构：树和二叉树之-堆排列 (万字详解)

已于 2023-09-25 08:14:12 修改
阅读量476 收藏 17
点赞数 21
文章标签： 算法 数据结构
于 2023-09-17 17:58:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77649794/article/details/132948302
版权

目录

树概念及结构

1.1树的概念

1.2树的表示

​编辑2.二叉树概念及结构

2.1概念

2.2数据结构中的二叉树：​编辑

2.3特殊的二叉树：

​编辑

2.4 二叉树的存储结构

2.4.1 顺序存储：

2.4.2 链式存储：

二叉树的实现及大小堆排列

1功能展示

2 定义基本结构

3 初始化

4打印

5销毁

6插入

7向上调整

8交换两数组元素之间的值

9删除

10向下调整

11取堆顶的元素

12 判断二叉树是否为空

13计算该二叉树元素个数

3，堆排列

1建堆

建堆方式1 时间复杂度：O(N*log(N))

建堆方式2 时间复杂度：O(N)

2排列数组 O(N * log(N))

成品展示

Head.h

Head.c

Test.c

树概念及结构

1.1树的概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它
叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
有一个特殊的结点，称为根结点，根节点没有前驱结点
除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集
合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以
有0个或多个后继
因此，树是递归定义的。

 

 

 

节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的为6
叶节点或终端节点：度为0的节点称为叶节点； 如上图：B、C、H、I…等节点为叶节点
非终端节点或分支节点：度不为0的节点； 如上图：D、E、F、G…等节点为分支节点
双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点； 如上图：A是B的父节点
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 如上图：B是A的孩子节点
兄弟节点：具有相同父节点的节点互称为兄弟节点； 如上图：B、C是兄弟节点
树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为6
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次； 如上图：树的高度为4
节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
森林：由m（m>0）棵互不相交的多颗树的集合称为森林；（数据结构中的学习并查集本质就是一个森林）

1.2树的表示

树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，实际中树有很多种表示方式，
如：双亲表示法，孩子表示法、孩子兄弟表示法等等。我们这里就简单的了解其中最常用的孩子
兄弟表示法。

typedef int DataType;
struct Node
{
struct Node* _firstChild1; // 第一个孩子结点
struct Node* _pNextBrother; // 指向其下一个兄弟结点
DataType _data; // 结点中的数据域
};

2.二叉树概念及结构

2.1概念

一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子
树和右子树的二叉树组成。
二叉树的特点：

  1. 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。
  2. 二叉树的子树有左右之分，其子树的次序不能颠倒。

2.2数据结构中的二叉树：

2.3特殊的二叉树：

  1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉
    树。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。
  2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对
    于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号
    从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉
    树

2.4 二叉树的存储结构

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。
二叉树的性质

  1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.
  2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h- 1.
  3. 对任何一棵二叉树, 如果度为0其叶结点个数为 n0, 度为2的分支结点个数为 n2,则有n0＝n2
    ＋1
  4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=LogN

2.4.1 顺序存储：

顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树
会有空间的浪费。而现实中使用中只有堆才会使用数组来存储，关于堆我们后面的章节会专门讲
解。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

2.4.2 链式存储：

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链，后面课程学到高阶数据结构如红黑树等会用到三叉链。

二叉树的实现及大小堆排列

本文将以写代码思路进行讲述，故中间会出现代码的优化以便梳理思路，渐入佳境

本文分成三个文件：

Head.h//函数的声明
Head.c//函数的创建
Test.c //用于测试文件

1功能展示

    //用数组的方式来表示二叉树基本结构
	typedef int HPDataType;
	typedef struct Heap
	{
		HPDataType* a;
		int size;
		int capacity;
	}HP;

	//初始化
	void HeapInit(HP* php);

	//交换两数组元素之间的值
	void Swap(HPDataType* p1,HPDataType* p2);

	//打印
	void HeapPrint(HP* php);

	//销毁
	void HeapDestroy(HP* php);

	//插入
	void HeapPush(HP* php,HPDataType x);

	//向下调整
	void AdjustDown(HPDataType* a, int size, int paarent);
	
	//向上调整
    void AdjustUp(HPDataType* a, int child);

	//删除
	void HeapPop(HP* php);

	//取堆顶的元素
	HPDataType HeapTop(HP* php);

	//判断是否为空
	bool HeapEmpty(HP* php);

	//计算该二叉树元素个数
	int HeapSize(HP* php);

2 定义基本结构

使用数组实现二叉树相较于链表有以下优势：
1. 内存连续性：数组在内存中是连续存储的，而链表中的节点可以分布在内存的任意位置。在某些场景下，数组的内存连续性可以提高访问效率，尤其对于计算机的缓存机制来说，连续的数组元素可以更好地利用缓存行，减少缓存缺失。
2. 索引访问：数组可以通过索引直接访问元素，而链表需要从头节点开始顺序遍历才能找到指定位置的节点。通过索引可以快速访问数组中的元素，这在一些特定的操作中是非常有优势的，例如查找某个特定位置的节点、根据节点索引快速更新或删除元素等。
3. 空间效率：相比链表，数组实现二叉树可以更加节省空间。链表除了存储节点本身的数据之外，还需要额外的指针来连接节点，而数组只需要存储节点数据，不需要额外的指针。
需要注意的是，链表在插入和删除节点的操作上通常比数组更加高效，因为插入和删除只需要改变相邻节点之间的指针指向，而数组需要移动元素。因此，在对二叉树进行频繁的插入和删除操作时，链表可能更适合。而数组适合于对二叉树进行频繁的随机访问和操作的场景。

//用数组的方式来表示二叉树基本结构
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

3 初始化

void HeapInit(HP* php)
{
	assert(php);

	php->a = NULL;
	php->size = php->capacity = 0;
}

4打印

void HeapPrint(HP* php)
{
	assert(php);
	for (int i = 0;i < php->size;i++)
	{
		printf("%d ", php->a[i]);
	}
	printf("\n");
}

5销毁

void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a=NULL;
	php->size = php->capacity = 0;
}

6插入

void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	//扩容
	if (php->size == php->capacity)
	{
		//判断capacity是否为0，并进行赋值
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = realloc(php->a, sizeof(HPDataType) * newcapacity);
		
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	php->a[php->size] = x;
	php->size++;

	//	   当前数组  插入数值的位置
	AdjustUp(php->a, php->size-1);
}

7向上调整

在插入元素之时，直接进行向上排序
将插入的元素与父辈元素进行比较，并进行互换

void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	
	//孩子被调到顶是结束(即数组首元素)
	while (child>0)
	{
		//if (a[child]<a[parent])  小堆
		if (a[child] > a[parent])//大堆
		{
			//孩子 小于/小于 父亲
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			//孩子 大于/小于 父亲
			break;
		}
	}
}

8交换两数组元素之间的值

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

9删除

将头部元素与尾部元素呼唤，以防直接删除头元素，倒是数据混乱
将其换到尾部进行删除，在将换到同部的尾元素进行向下比较，
进行替换，寻找新的(最大/最小)头部元素

void HeapPop(HP* php)
{
	assert(php);
	assert(php->size>0);
	Swap(&(php->a[0]), &(php->a[php->size - 1]));
	php->size--;

	//向下调整
	AdjustDown(php->a, php->size, 0);
}

10向下调整

void AdjustDown(HPDataType* a, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child<size)
	{
		//选出左右孩子中 小/大 的那个
		//if (child+1<size && a[child + 1] < a[child])
		if (child + 1 < size && a[child + 1] > a[child])
		{
			++child;
		}

		//跟孩子父亲比较
		//if (a[child]<a[parent])
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			//左右孩子都大于/小于父亲，结束交换
			break;
		}
	}
}

11取堆顶的元素

//取堆顶的元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);

	return php->a[0];
}

12 判断二叉树是否为空

bool HeapEmpty(HP* php)
{
	assert(php);
	
	return php->size == 0;
}

13计算该二叉树元素个数

int HeapSize(HP* php)
{
	assert(php);

	return php->size ;
}

3，堆排列

此时二叉树已近成型，但进行排列时会设计到复杂度的问题，之前的代码中存在问题，效率低下
此时的问题：
1,你得先写一个Hp数据结构，反而复杂
2，有o(N)空间复杂度
每次使用建堆选数据
整体时间复杂度O(N^2)
效率太低，没有使用到堆的优势
每次使用堆排列时都要重新创建一个数据结构，并依次插入进行排序无疑是增加了时间复杂度
应该直接利用本身的数组进行堆排列

1建堆

建堆方式1 时间复杂度：O(N*log(N))

一共N个数，每个数向上调整log(N)次(层数，依次对父辈进行交换)
故为 O(Nlog(N))

for (int  i = 1; i < n; i++)
	{
	 //每插入一个，进行一次向上调整
		AdjustUp(a, i);
	}

这段代码使用了一个循环，其中执行了n-1次迭代（从i=1到i<n）。每次循环内部都会调用AdjustUp(a, i)进行向上调整的操作。
在循环内部，执行向上调整的操作的时间复杂度是O(log(i))，其中i是当前循环的迭代次数。因为每次执行向上调整时，需要比较和交换的次数与当前节点所在二叉树的高度有关，而二叉树的高度是随着节点的插入逐渐增加的，即高度与插入的节点数量有关。
根据每次迭代的时间复杂度为O(log(i))，加上n-1次的循环，总的时间复杂度为: O(log(1) + log(2) + … + log(n-1))
对于这个求和过程，并没有一个简单的封闭解析解。但根据级数求和的性质，可以得到这个求和结果的上界为O(n * log(n))。因此，可以将上述代码的时间复杂度近似地表示为O(n * log(n))。
需要注意，这个时间复杂度是在假设AdjustUp的时间复杂度为O(log(i))的情况下得到的。如果AdjustUp的时间复杂度比O(log(i))更高，那么整个代码块的时间复杂度将会增加。

建堆方式2 时间复杂度：O(N)

从最后一个非叶节点进行插入

for (int i = (n - 1) / 2; i >= 0; i--)
	{
		//最后一个非叶节点：(n - 1) / 2
		//向下调整前提是字树必须是大/小堆
		AdjustDown(a, n, i);
	}

这段代码使用了一个循环，其中执行了(n-1)/2+1次迭代，从i=(n-1)/2到i=0。
每次循环内部都会调用AdjustDown(a, n, i)进行向下调整的操作。
在循环内部，执行向下调整的操作的时间复杂度是O(log(n))，其中n是当前二叉树的节点数量。因为每次执行向下调整时，需要比较和交换的次数与当前节点所在的子树的节点数量有关，而每个节点至多有两个子节点，所以向下调整的时间复杂度是与当前节点所在的子树高度相关，即O(log(n))。
根据每次迭代的时间复杂度为O(log(n))，加上(n-1)/2+1次的循环，总的时间复杂度为: O(log(n) + log(n) + … + log(n))
展开求和后，得到 (n-1)/2+1 次 log(n) 相加。根据级数求和的性质，这个求和结果为 O(n)。因此，可以将上述代码的时间复杂度近似地表示为 O(n)。

2排列数组 O(N * log(N))

此时二叉树已经排列完成，在二叉树图像中元素已经按照 大堆/小堆 排好
但在数组中依旧是混乱排列，要做到像堆排列，就需要将数组进行排列
升序打印数组：大堆
降序打印数组：小堆
这里似乎与之前相反

之前：
升序/降序 打印是要将首元素置换到末元素，并进行打印删除，被置换的元素向下调整
故为升序打印为小堆，降序为大堆

而此处我们要将数组按照大小堆的形式排列：

	while (end>0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;//--end缩小范围保证是按照数组 大/小 堆排序
	}


若原本二叉树排列为大堆，该代码就将数组排列成大堆
故 升序建大堆，降序建小堆

成品展示

Head.h

#pragma once
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>

//用数组的方式来表示二叉树基本结构
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

//初始化
void HeapInit(HP* php);

//交换两数组元素之间的值
void Swap(HPDataType* p1, HPDataType* p2);

//打印
void HeapPrint(HP* php);

//销毁
void HeapDestroy(HP* php);

//插入
void HeapPush(HP* php, HPDataType x);

//向上调整
void AdjustUp(HPDataType* a, int child);

//向下调整
void AdjustDown(HPDataType* a, int size, int paarent);

//删除
void HeapPop(HP* php);

//取堆顶的元素
HPDataType HeapTop(HP* php);

//判断是否为空
bool HeapEmpty(HP* php);

//计算该二叉树元素个数
int HeapSize(HP* php);

Head.c

#include "Head.h"

//初始化
void HeapInit(HP* php)
{
	assert(php);

	php->a = NULL;
	php->size = php->capacity = 0;
}

//打印
void HeapPrint(HP* php)
{
	assert(php);
	for (int i = 0;i < php->size;i++)
	{
		printf("%d ", php->a[i]);
	}
	printf("\n");
}

//销毁
void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}

//交换两数组元素之间的值
void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向上调整
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;

	//孩子被调到顶是结束(即数组首元素)
	while (child > 0)
	{
		if (a[child]<a[parent])  //小堆
		{
			//孩子 小于/小于 父亲
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			//孩子 大于/小于 父亲
			break;
		}
	}
}

//插入
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	//扩容
	if (php->size == php->capacity)
	{
		//判断capacity是否为0，并进行赋值
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = realloc(php->a, sizeof(HPDataType) * newcapacity);

		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	php->a[php->size] = x;
	php->size++;

	//	   当前数组  插入数值的位置
	AdjustUp(php->a, php->size - 1);

}

//向下调整
void AdjustDown(HPDataType* a, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		//选出左右孩子中 小/大 的那个
		if (child+1<size && a[child + 1] < a[child])
		{
			++child;
		}

		//跟孩子父亲比较
		if (a[child]<a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			//左右孩子都大于/小于父亲，结束交换
			break;
		}
	}
}

//删除
void HeapPop(HP* php)
{
	assert(php);
	assert(php->size > 0);

	Swap(&(php->a[0]), &(php->a[php->size - 1]));
	php->size--;

	//向下调整
	AdjustDown(php->a, php->size, 0);
}

//取堆顶的元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);

	return php->a[0];
}

//判断是否为空
bool HeapEmpty(HP* php)
{
	assert(php);

	return php->size == 0;
}

//计算该二叉树元素个数
int HeapSize(HP* php)
{
	assert(php);

	return php->size;
}

Test.c

Test.c只是用于测试代码，菜单的写法本文将不进行讲解。
但Test.c中含有对查找and销毁and存储链元素个数的使用方法进行了示例可以当参考。

#include "Head.h"

void test1()
{
	//升序打印--小堆
	//降序打印--大堆
	HP hp;
	HeapInit(&hp);
	int a[] = { 27,15,19,18,28,34,65,49,25,37 };

	int sz = sizeof(a) / sizeof(a[0]);
	//将数组插入新的堆
	for (int i = 0;i < sz;i++)
	{
		HeapPush(&hp, a[i]);
	}

	while (!HeapEmpty(&hp))
	{
		printf("%d ", HeapTop(&hp));
		HeapPop(&hp);
	}
}

void test2()
{
	HP hp;
	HeapInit(&hp);
	int a[] = { 27,15,19,18,28,34,65,49,25,37 };

	int sz = sizeof(a) / sizeof(a[0]);
	//将数组插入新的堆
	for (int i = 0;i < sz;i++)
	{
		HeapPush(&hp, a[i]);
	}
	int i = 0;
	while (!HeapEmpty(&hp))
	{
		a[i++] = HeapTop(&hp);
		HeapPop(&hp);
	}
	HeapDestroy(&hp);
}

void test3()
{
	HP hp;
	HeapInit(&hp);
	int a[] = { 27,15,19,18,28,34,65,49,25,37 };

	int sz = sizeof(a) / sizeof(a[0]);
	//将数组插入新的堆
	for (int i = 0;i < sz;i++)
	{
		HeapPush(&hp, a[i]);
	}
	HeapPrint(&hp);
}
//此时的问题：
//1,你得先写一个Hp数据结构，反而复杂
//2，有o(N)空间复杂度
/*
	每次使用建堆选数据
	整体时间复杂度O(N^2)
	效率太低，没有使用到堆的优势
*/
void test4(int*a ,int n)
{
	//本生就是一个数组，直接利用自身建堆
	//建堆
	//  建堆方式1  时间复杂度：O(N*log(N))
	//for (int  i = 1; i < n; i++)
	//{
	// //每插入一个，进行一次向上调整
	//	AdjustUp(a, i);
	//}

	//  建堆方式2  时间复杂度：O(N)
	for (int i = (n - 1) / 2; i >= 0; i--)
	{
		//最后一个非叶节点：(n - 1) / 2
		//向下调整前提是字树必须是大/小堆
		AdjustDown(a, n, i);
	}

}

/*
	1.将 最大的数/最小的数 换到 最小的数/最大的数，
	并删除被换的数(最后的数)
	2.然后对 头部进行降序(将 最小的数/最大的数 下移，
	重新找到 最大/最小 的数换到头部) 
	
	将效率提升至O(N*log(N))
*/
//升序 --建大堆
//降序 --建小堆
void test5(int* a, int n)
{
	//时间复杂度：O(N)
	for (int i = (n - 1) / 2; i >= 0; i--)
	{
		//最后一个非叶节点：(n - 1) / 2
		//向下调整前提是字树必须是大/小堆
		AdjustDown(a, n, i);
	}
	int end = n - 1;
	//O(N * log(N))->O(N)+O(N * log(N))=O(N * log(N))
	while (end>0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

int main()
{
	int a[] = { 5, 3, 2, 9, 7, 4, 1, 10, 8, 6};
	int sz = sizeof(a) / sizeof(a[0]);
	test5(a,sz);

	return 0;
}

本文到这就结束啦，本文为万字解读，创作不易，若喜欢请留下免费的赞吧！
感谢阅读😊😊😊

努力学c的楼下小王
关注
  • 21
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 20
    评论
【回溯法】用子集树和排序树解决n后问题
ganlubaba666的博客
05-21 3013
回溯法 在问题的解空间树中，按深度优先策略，根节点触发搜索解空间树，算法搜索至解空间的任意节点时，先判断该节点是否包含问题的解，若肯定不包含，则跳过对以该节点为根的子树的搜索，逐层向其祖先结点回溯。否则进入该子树，继续按根深度优先搜索 子集树和排列树的区别 当所给问题是从n个元素的集合S中找出满足某种性质的子集时，相应的解空间树称为子集树。子集树的时间复杂度为2^n 当所给的问题时确定n个元素满...
老卫带你学---排序、查找、树图的时间复杂度
老卫带你学
03-30 377
排序、查找、树图的时间复杂度 (1)冒泡排序 冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。 (2)选择排序 选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的。…… 例子说明好多了。序列5 8 5 2 9， 我们知道第一遍选择第1个元素5会和2交换，那么原序...
算法：排序 二叉树深度时间复杂度？ 归并和快速排序实践？B树时间复杂度？
u010287873的博客
01-10 2696
概念：以某个值或值的集合为输入，将输入转换成输出的计算步骤的一个序列。 O(1)<O(logn)<O(n)<O(nlogn)<O(n*n) 算法的时间复杂度用来衡量随问题规模n的增长执行次数的增长率。 常见排序： 插入排序 遍历数组，遍历到i时，a0,a1...ai-1是已经排好序的，取出ai，从ai-1开始从后向前和每个比较大小(从前向后比的话需要考...
416-回溯算法-排列树
LINZEYU666的博客
08-16 3765
解空间-排列树的理解 原始序列的全排列。不同的排列方式。 比如说1234有很多排列方式，可能只有其中几种排列方式才满足题目的要求。 举个例子： 我们现在想获取1,2，3,4的全排列 就是每个元素在各个位置上都出现1遍！ 首先，我们从第1个位置开始。 第一个位置可以放1，剩下的就是2,3，4 第一个位置还可以放2，剩下的就是1,3，4 第一个位置还可以放3，剩下的就是2,1，4 第一个位置还可以放4，剩下的就是2,3，1 我们先处理第1个位置的元素，我拿第一个位置的元素和每个位置的元素交换一下，这样就可以把每
经典排序算法的时间复杂度和空间复杂度
玲珑骰子安红豆，入骨相思知不知
05-12 1662
时间复杂度 一、常见的七种时间复杂度：大O表示法–Big O notation O（1）：常数复杂度 Constant Complexity O（log n）：对数复杂度 Logarithmic Complexity O（n）： 线性时间复杂度 Linear Complexity O（n^2）： N平方 N square Complexity O（n^3）： N立方 N cubic Complexity O（2^n）：指
数据结构与算法：树和二叉树.pptx
05-11
二叉树是树结构的一种特例，每个结点最多有两个子结点，分别称为左子结点和右子结点。二叉树的定义是递归的，由一个根结点和两个二叉子树构成。二叉树在计算机科学中广泛应用，因其结构简单、存储效率高、操作算法...
数据结构--二叉树--思维导图.pdf
08-29
"数据结构--二叉树--思维导图" 二叉树是一种常见的数据结构，它是一种树形结构，每个节点最多有两个孩子节点，分别是左子树和右子树。二叉树可以用来存储大量数据，并且可以快速地查找、插入和删除数据。 二叉树的...
数据结构-树和二叉树-PPT
02-04
数据结构-树和二叉树-PPT 树是一种非常重要的非线性数据结构，它用于描述数据元素之间的层次关系。在客观世界中，树形结构广泛存在，如人类社会的族谱和各种社会组织机构都可用树来形象表示。 树的定义：树是一棵n...
数据结构基础系列(6)：树和二叉树
06-08
数据结构课程是计算机类专业的专业基础...系列课程包含11个部分，本课为第6部分“树和二叉树”，介绍树的相关概念和表示方法，重点是二叉事的性质、存储结构、遍历等基本操作的实现，以及应用基本操作解决问题的方法。
数据结构 实验3：树和二叉树的应用-哈夫曼编码设计
08-01
数据结构完整实验报告 实验3：树和二叉树的应用-哈夫曼编码设计
[算法之回溯法] 子集树与排列树
LEAKERS_ZZW的专栏
07-14 2294
当所给的问题是从n个元素的集合S中找出满足某种性质的排列时，相应的解空间即使一颗子集树。这类子集树通常有2^n个节叶节点。所需要的时间复杂度是O（2^n）;     当所给的问题确定n个元素满足某种性质的排列时，相应的解空间树成为排列树。排列树有n！个叶结点。因此遍历该树所用的时间复杂度是O（n!）     回溯法搜索子集树算法描述为：      void backtrack(int
【回溯算法】子集数与排列树模板
Woo~
04-12 766
有时问题是要从一个集合的所有子集中搜索一个集合，作为问题的解。 或者从一个集合的排列中搜索一个排列，作为问题的解。 回溯算法可以很方便地遍历一个集合的所有子集或者所有排列。 子集树 当问题是要计算n个元素的子集，以便达到某种优化目标时，可以把这个解空间组织成一棵子集树。 例如，n个物品的0-1背包问题相应的解空间树就是一棵子集树。 这类子集树通常有2n个叶结点，结点总数为2(n +1)-1。(n+1)为上标 遍历子集树的任何算法，其计算时间复杂度都是Ω(2n),2的n次方。 //形参t为树
数据结构-排列树（以及八皇后问题）
weixin_44856859的博客
08-07 5332
排列树 什么是排列树？ 全排列是什么？ 很多人会看到排列树会想起子集树，那两者有什么区别？ 排列树如何应用呢？ 1.排列树： 定义：当所给的问题是确定n个元素满足某种性质的排列时，行营的解空间称为排列树 排列树特点：n层满n叉树，时间复杂度为O(n!) 2.全排列 从n个不同元素中任取m(m<=n)个元素，按一定的顺序排列起来。 n个数的全排列共有n!中因此全排列算法排列至少时间为o(n!)...
7. 二叉排序树的搜索、插入、删除，时间复杂度
谢语天
08-08 2万+
二叉排序树又称二叉查找树，它或是一棵空的er
二叉排序树（二叉搜索树）的时间复杂度&空间复杂度
热门推荐
xuxinrk的博客
04-26 5万+
二叉排序树又称二叉查找树（二叉搜索树），它或是一棵空的二叉树，或是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有节点的值均小于根节点的值 若它的右子树不空，则右子树上所有节点的值均大于根节点的值 它的左右子树也都是二叉排序树 如果二叉排序树是平衡的，则n个节点的二叉排序树的高度为,其查找效率为，近似于折半查找。如果二叉排序树完全不平衡，则其深度可达到n，查找效率为O(n)，退化为顺...
排序 查找 树 图 的时间复杂度
weixin_30586085的博客
04-26 254
查找算法 时间复杂度 顺序查找 O(n) 算法简单，适应面广，稳定算法 折半查找 O(log2n) 针对有序的序列表，不稳定 分块查找 介于顺序查找和折半查找之间 针对有序表，不稳定算法 平衡二叉树查找 O(log2n) 插入与删除的复杂度也相同 排序法 平均时间...
b 树查找时间复杂度_二叉排序树的时间复杂度
weixin_33498296的博客
12-29 1255
终于开始写二叉排序树。。如果这里有个程序，里面有两个程序块，它们是先后顺序。第一个程序块运行时间复杂度是O(n)第二个程序块运行时间复杂度也是O(n)我的大脑就会觉得这个程序总的时间复杂度就是=O(n)+O（n)好像很大，，，，好像其实比起O(n^2)还是小的。。。因为常数系数似乎可以忽略不计。--------------------------------可能因为我大脑不喜欢复杂的东西，所以 …...
算法014：找到字符串中所有字母异位词
最新发布
m0_62319039的博客
07-14 438
算法014：找到字符串中所有字母异位词
数据结构：树与二叉树详解 - 逻辑结构、度与层次特性
第5章"树和二叉树"是关于数据结构中的重要概念，主要探讨了树的理论基础及其在实际应用中的体现。树是一种非线性数据结构，其逻辑结构通过递归定义，具有层次性和互不相交的特性，确保了结构的清晰和无环。以下是本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 20
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值