数据结构初阶：二叉树_struct treenode，2024年最新成功跳槽阿里

最新推荐文章于 2024-08-24 23:42:41 发布

2401_83946722

最新推荐文章于 2024-08-24 23:42:41 发布

阅读量613

点赞数 12

分类专栏： 2024年程序员学习文章标签：数据结构跳槽网络

本文链接：https://blog.csdn.net/2401_83946722/article/details/138007679

版权

2024年程序员学习专栏收录该内容

265 篇文章 0 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新网络安全全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

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

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

如果你需要这些资料，可以添加V获取：vip204888 （备注网络安全）

正文

上面的方式各有优劣，表示树结构的最优方法是左孩子右兄弟表示法。

struct TreeNode 
{
    TNDataType data; 

    struct TreeNode\* firstChild;
    struct TreeNode\* nextBrother;
};

结点的指针域只存两个指针：

firstChild指向该结点的第一个子结点，
nextBrother指向子结点右边的第一个兄弟结点。以此像单链表的形式链接兄弟节点。

第一层，根结点

A

A

A ，无兄弟结点。

第二层，结点

A

A

A 的第一个子结点为

B

B

B，其兄弟结点为

C

C

C。

第三层，结点

B

B

B 的第一个子结点为

D

D

D，其兄弟结点为

E

E

E，

F

F

F。结点

C

C

C 的子结点为

G

G

G。

第四层，结点

D

D

D 无子结点，结点

E

E

E 有子结点为

H

H

H。结点

F

F

F，

G

G

G 无子结点 … ….

只要确定根结点，其余所有的结点都可以从其父结点或兄弟结点的指针处找到，如果没有指针就为空。

这种方法不需要确定树的度

N，也不需要使用线性表存储，结构不复杂也不浪费空间，不失为树结构的最优表示法。

树在计算机中最经典的应用就是文件管理系统即目录树。当打开文件夹时，弹出的一系列子文件夹，更类似于先找到子结点再找到其兄弟结点。

2. 二叉树

用于存储和管理数据，最常见的是二叉树。

2.1 二叉树的定义

二叉树的每个结点可无子树或有一个子树，但最多有两个子树，分别称为左子树和右子树。如图：

二叉树不存在度大于2的结点。同样二叉树的度最大为2。

度为0时树为空。度为1时是线性结构，度为2时存在可能有两个子树的结点。

二叉树中结点的子树有左右之分，且次序不可颠倒。
任意二叉树由以下几种情况复合而成：

特殊二叉树

二叉树中有两种特殊的二叉树，分别是满二叉树和完全二叉树。

满二叉树：所有的叶结点都在最后一层，也就是所有分支结点都有两个子树，也就是每层结点数都到达最大值，这样的数就是满二叉树。

假设满二叉树的层数

h

h

h，则第

h

h

h 层的结点数为

2

h

−

1

2^{h-1}

2h−1，结点总数是

2

h

−

1

2^h-1

2h−1 。

若已知结点总数为

N

N

N，则树的高度为

l

o

g

2

(

N

1

)

log_2(N+1)

log2(N+1)。

完全二叉树：完全二叉树的前

−

n-1

n−1 层为满二叉树，最后一层虽可不满但一定是从左至右连续。

满二叉树是一种特殊的完全二叉树。

二叉树的性质

二叉树的第

i 层上最多有

−

2^{i-1}

2i−1 个结点。
2. 对于深度为

h 的二叉树，最大结点数为

−

2^h-1

2h−1，最少节点数为

−

2^{h-1}

2h−1。
3. 任意二叉树，假设其叶结点个数

n0 总比度为2的分支结点

n2 个数大

1，即

n_0=n_2+1

n0=n2+1。

二叉树的特点就是：每增加一个分支结点，必然会增加一个叶节点。

完全二叉树度为

1 的结点个数，要么为

0，要么为

1。
5. 若满二叉树结点总数为

N，则树的高度为

(

)

h=log_2(N+1)

h=log2(N+1)。

2.2 二叉树的结构

普通二叉树的增删查改无甚意义，更多是学习对二叉树结构的控制。为后期学习搜索二叉树、AVL树和红黑树夯实基础。

顺序存储

顺序存储即用数组按层序顺序一层一层的存储节点。

有些“缺枝少叶”的树存入数组，若不浪费空间便不好规律地表示结构。故一般数组只适用于表示完全二叉树。

更重要的是，可以利用数组下标计算结点的父子结点位置。如图：

∗

leftChild=parent*2+1\ rightChild=parent*2+2

leftChild=parent∗2+1rightChild=parent∗2+2

如果计算得的孩子下标越界，则说明该节点不存在对应的子节点。

(

−

)

parent=(child-1);/;2

parent=(child−1)/2

链式存储

使用链表表示二叉树，更加的直观。通常方案有两种一个是二叉链表，一个是三叉链表。二叉链表即存数据域和左右指针域，三叉则多存一个父结点指针。

当前数据结构一般都是二叉链，红黑树等高阶数据结构会用到三叉链。当前仅作了解。

// 二叉链
struct BinaryTreeNode {
    struct BinTreeNode\* leftChild;
    struct BinTreeNode\* rightChild;
	BTDataType _data; 
};
// 三叉链
struct BinaryTreeNode {
	struct BinTreeNode\* parentChild;
	struct BinTreeNode\* leftChild;
	struct BinTreeNode\* _pRight; 
	BTDataType _data;
};

3. 堆

3.1 堆的定义

堆是一种数据结构，他是完全二叉树的一种应用，故堆的底层采用数组作底层结构。

需注意，此刻所讨论的堆是一种抽象数据结构，和内存中的堆没有关系。

定义一个值的集合

{

−

}

\lbrace k_0,k_1,k_2,…,k_{n-1} \rbrace

{k0,k1,k2,…,kn−1}，将其以二叉树顺序存储（层序遍历）的方式存储于数组中，且满足一定规律：

≤

∗

≤

∗

K_i ≤ K_{2*i+1}; && ; K_i ≤ K_{2*i+2}

Ki≤K2∗i+1&&Ki≤K2∗i+2

≥

∗

≥

∗

K_i ≥ K_{2*i+1}; && ; K_i ≥ K_{2*i+2}

Ki≥K2∗i+1&&Ki≥K2∗i+2

公式

(

)

(5)

(5) 要求每个结点都比其子结点小或相等，这样的堆被称为小堆或小根堆。

反之，公式

(

)

(6)

(6) 要求每个结点都比其子结点大或相等，这样的堆被称为大堆或大根堆。

可以看出，堆是一个完全二叉树，且堆中某个结点的值总是不大于或不小于其子结点的值。但堆并不是有序的，只有存储堆的数组有序，才称堆有序。

3.2 堆的实现

堆的逻辑结构是一个完全二叉树，物理结构是一个数组。也可以认为完全二叉树实际上就是个数组，或着是把数组想象成完全二叉树。

堆的结构

typedef int HPDataType;

typedef struct heap {
    HPDataType\* a;
	int size;
    int capacity;
}heap;

堆的插入

void HeapPush(heap\* php, HPDataType x) 
{
	assert(php);
	if (php->size == php->capacity) 
    {
		int newCapacity = php->capacity == 0 ? 4 : php->capacity \* 2;
		HPDataType\* tmp = (HPDataType\*)realloc(php->a, sizeof(HPDataType) \* newCapacity);
		if (tmp == NULL) 
        {
			perror("HeapPush::malloc");
			exit(-1);
		}
		
        php->a = tmp;
		php->capacity = newCapacity;
	
    }
	php->a[php->size] = x;
	php->size++;
	
    //调整
	AdjustUp(php->a, php->size, php->size - 1);
}

堆插入就是在数组的末尾进行插入，就是在二叉树上加一个叶结点。

由于插入的数值不一定，堆的性质可能被破坏。但插入新结点只会影响其到根结点的这条路径上的结点，故需要顺势向上调整：一直交换结点数值直到满足堆的性质即可。

向上调整算法

void AdjustUp(HPDataType\* a, int size, int child) 
{
	assert(a);
    int parent = (child - 1) / 2;
    
	while (child > 0) 
    {
		//大堆
		if (a[child] > a[parent]) 
			Swap(&a[child], &a[parent]);
		else 
			break;
        
		//迭代
        child = parent;
        parent = (child - 1) / 2;
	}
}

向上调整算法，从child处一直向上找父结点，满足子结点比父节点大或小的条件就交换，直到调整到根结点或不满足条件为止。

堆的向上调整较为容易，因为结点的父结点只有一个，只需要和父节点比较即可。

堆的删除

void HeapPop(heap\* php) 
{
	assert(php);
	assert(!HeapEmpty(php));

    //删除
	php->a[0] = &php->a[php->size - 1];
	php->size--;
	
    //调整
	AdjustDown(php->a, php->size, 0);
}

堆的删除就是删除堆顶元素，但不能简单的将数组整体向前挪一位，这样会使破坏堆的结构。

应该先修改堆顶元素的值为数组末尾元素的值，再删除数组末尾元素。此时再从堆顶位置向下调整，就能恢复堆结构。

向下调整算法

//大根堆
void AdjustDown(HPDataType\* a, int size, int parent) 
{
	int child = parent \* 2 + 1;

	while (child < size) // 等遍历到叶节点时，child迭代到叶节点的子节点必越界
    {
		if (child + 1 < size && a[child + 1] > a[child]) // 选出大子结点
			child++;
		
		//交换
		if (a[child] > a[parent]) 
			Swap(&a[child], &a[parent]);
		else 
			break;
        
        //迭代
        parent = child;
        child = parent \* 2 + 1;
	}
}

把尾元素换到堆顶，必然会改变堆的性质。但根结点的左右子树还是保持原有的性质。所以只需要将堆顶元素逐步向下调整。

以大根堆为例，从根开始，将当前结点与其较大的子结点进行交换，直到走到叶结点或不满足条件为止。

将较大的子结点换上来就是在恢复大堆性质，将较小的子结点交换上来是在恢复小堆性质。

堆的插入删除的时间复杂度，也就是向上向下调整算法的时间复杂度都是

logN

logN。

建堆

给出数组a，数组逻辑上可以看成完全二叉树，但并不一定是堆。建堆就是将数组调整成堆。

方法1：向上调整

从根结点开始，依次将数组元素“插入”堆，与其说是“插入”不如说是“加入”。利用下标遍历数组，每插入一个就调整一次。

假设需要将a排成升序，不妨先试试将a数组构建成小堆：

//建堆
void HeapBuild(int\* a, int sz) {
    //向上调整
	for (int i = 1; i < sz; i++) {//从第二个结点开始遍历到尾结点
		AdjustUp(a, sz, i);
	}
}

每加入一个元素，就向上调整。思想上其实和接口Push是一样的，都是插入再调整。也可以理解为“边建边调”。

方法2：向下调整

此时数组当然还不是堆，向下调整算法要求左右子树必须满足堆的性质，才能将当前节点向下调整。应先从最后一个子树开始向下调整，从后向前倒着遍历。

准确来说，因为叶结点必然满足堆的性质，所以不用关心。应从尾结点的父结点所在子树开始，遍历到根结点进行调整。

//建堆
void HeapBuild(int\* a, int sz) {
    //向下调整
	for (int i = (sz - 1 - 1) / 2; i >= 0; i--) {//从最后一个叶结点的父结点开始到根结点
		AdjustDown(a, sz, i);
	}
}

从一个完全二叉树的尾结点的父结点开始，从后往前调，也可以看成“建完在调”。

建堆的两种方式，向上调整和向下调整都是可行的。建大堆还是建小堆，只要改比较符号即可。

建堆复杂度

遍历数组 N 个节点，每个节点调整 logN 次，故向上调整建堆的时间复杂度为

(

∗

)

O(N*logN)

O(N∗logN) 。

向上调整算法复杂度过高，建堆一般配合堆排序使用的是向下调整算法。

向下调整的最复杂情况是从根结点一直调整到叶结点，并以满二叉树为例，看最复杂情况。

假设当前树有

n 个结点，树的高度为

h ，可得：

第 1 层有

2^0

20 个结点，每个结点最多调整

−

h-1

h−1 次，
2. 第 2 层有

2^1

21 个结点，每个结点最多调整

−

h-2

h−2 次，
3. 以此类推，第

−

h-1

h−1 层有

−

2^{h-2}

2h−2 个结点，每个结点最多调整

1 次。

精确计算下，第

x 层的所有节点的总调整次数，应为

−

∗

(

−

)

2^{x-1}*(h-x)

2x−1∗(h−x)。

T

(

n

)

T(n)

T(n) 为差比数列，利用错位相减法得

T

(

n

)

T(n)

T(n) 关于

h

h

h 的表达式，再由

n

=

2

h

−

1

,

h

=

l

o

g

2

(

n

1

)

n=2^h-1,h=log_2{(n+1)}

n=2h−1,h=log2(n+1) 将

T

(

n

)

T(n)

T(n)转换成关于的

n

n

n的表达式。