树与二叉树的常用算法
二叉树的遍历及常用算法
⼆叉树的遍历及常⽤算法⼆叉树的遍历及常⽤算法遍历的定义:按照某种次序访问⼆叉树上的所有结点,且每个节点仅被访问⼀次;遍历的重要性:当我们需要对⼀颗⼆叉树进⾏,插⼊,删除,查找等操作时,通常都需要先遍历⼆叉树,所有说:遍历是⼆叉树的基本操作;遍历思路:⼆叉树的数据结构是递归定义(每个节点都可能包含相同结构的⼦节点),所以遍历也可以使⽤递归,即结点不为空则继续递归调⽤每个节点都有三个域,数据与,左孩⼦指针和右孩⼦之指针,每次遍历只需要读取数据,递归左⼦树,递归右⼦树,这三个操作三种遍历次序:根据访问三个域的不同顺序,可以有多种不同的遍历次序,⽽通常对于⼦树的访问都按照从左往右的顺序;设:L为遍历左⼦树,D为访问根结点,R为遍历右⼦树,且L必须位于R的前⾯可以得出以下三种不同的遍历次序:先序遍历操作次序为DLR,⾸先访问根结点，其次遍历根的左⼦树，最后遍历根右⼦树，对每棵⼦树同样按这三步(先根、后左、再右)进⾏中序遍历操作次序为LDR,⾸先遍历根的左⼦树，其次访问根结点，最后遍历根右⼦树，对每棵⼦树同样按这三步(先左、后根、再右)进⾏后序遍历操作次序为LRD,⾸先遍历根的左⼦树，其次遍历根的右⼦树，最后访问根结点，对每棵⼦树同样按这三步(先左、后右、最后根)进⾏层次遍历层次遍历即按照从上到下从左到右的顺序依次遍历所有节点,实现层次遍历通常需要借助⼀个队列,将接下来要遍历的结点依次加⼊队列中;遍历的应⽤“遍历”是⼆叉树各种操作的基础，可以在遍历过程中对结点进⾏各种操作，如:对于⼀棵已知⼆叉树求⼆叉树中结点的个数求⼆叉树中叶⼦结点的个数;求⼆叉树中度为1的结点个数求⼆叉树中度为2的结点个数5求⼆叉树中⾮终端结点个数交换结点左右孩⼦判定结点所在层次等等...C语⾔实现:#include <stdio.h>//⼆叉链表数据结构定义typedef struct TNode {char data;struct TNode *lchild;struct TNode *rchild;} *BinTree, BinNode;//初始化//传⼊⼀个指针令指针指向NULLvoid initiate(BinTree *tree) {*tree = NULL;}//创建树void create(BinTree *BT) {printf("输⼊当前结点值: (0则创建空节点)\n");char data;scanf(" %c", &data);//连续输⼊整形和字符时.字符变量会接受到换⾏,所以加空格if (data == 48) {*BT = NULL;return;} else {//创建根结点//注意开辟的空间⼤⼩是结构体的⼤⼩⽽不是结构体指针⼤⼩,写错了不会⽴马产⽣问题,但是后续在其中存储数据时极有可能出现内存访问异常(飙泪....) *BT = malloc(sizeof(struct TNode));//数据域赋值(*BT)->data = data;printf("输⼊节点 %c 的左孩⼦ \n", data);create(&((*BT)->lchild));//递归创建左⼦树printf("输⼊节点 %c 的右孩⼦ \n", data);create(&((*BT)->rchild));//递归创建右⼦树}}//求双亲结点(⽗结点)BinNode *Parent(BinTree tree, char x) {if (tree == NULL)return NULL;else if ((tree->lchild != NULL && tree->lchild->data == x) || (tree->rchild != NULL && tree->rchild->data == x))return tree;else{BinNode *node1 = Parent(tree->lchild, x);BinNode *node2 = Parent(tree->rchild, x);return node1 != NULL ? node1 : node2;}}//先序遍历void PreOrder(BinTree tree) {if (tree) {//输出数据printf("%c ", tree->data);//不为空则按顺序继续递归判断该节点的两个⼦节点PreOrder(tree->lchild);PreOrder(tree->rchild);}}//中序void InOrder(BinTree tree) {if (tree) {InOrder(tree->lchild);printf("%c ", tree->data);InOrder(tree->rchild);}}//后序void PostOrder(BinTree tree) {if (tree) {PostOrder(tree->lchild);PostOrder(tree->rchild);printf("%c ", tree->data);}}//销毁结点递归free所有节点void DestroyTree(BinTree *tree) {if (*tree != NULL) {printf("free %c \n", (*tree)->data);if ((*tree)->lchild) {DestroyTree(&((*tree)->lchild));}if ((*tree)->rchild) {DestroyTree(&((*tree)->rchild));}free(*tree);*tree = NULL;}}// 查找元素为X的结点使⽤的是层次遍历BinNode *FindNode(BinTree tree, char x) {if (tree == NULL) {return NULL;}//队列BinNode *nodes[1000] = {};//队列头尾位置int front = 0, real = 0;//将根节点插⼊到队列尾nodes[real] = tree;real += 1;//若队列不为空则继续while (front != real) {//取出队列头结点输出数据BinNode *current = nodes[front];if (current->data == x) {return current;}front++;//若当前节点还有⼦(左/右)节点则将结点加⼊队列if (current->lchild != NULL) {nodes[real] = current->lchild;real++;}if (current->rchild != NULL) {nodes[real] = current->rchild;real++;}}return NULL;}//层次遍历// 查找元素为X的结点使⽤的是层次遍历void LevelOrder(BinTree tree) {if (tree == NULL) {return;}//队列BinNode *nodes[1000] = {};//队列头尾位置int front = 0, real = 0;//将根节点插⼊到队列尾nodes[real] = tree;real += 1;//若队列不为空则继续while (front != real) {//取出队列头结点输出数据BinNode *current = nodes[front];printf("%2c", current->data);front++;//若当前节点还有⼦(左/右)节点则将结点加⼊队列if (current->lchild != NULL) {nodes[real] = current->lchild;real++;}if (current->rchild != NULL) {nodes[real] = current->rchild;real++;}}}//查找x的左孩⼦BinNode *Lchild(BinTree tree, char x) {BinTree node = FindNode(tree, x);if (node != NULL) {return node->lchild;}return NULL;}//查找x的右孩⼦BinNode *Rchild(BinTree tree, char x) {BinTree node = FindNode(tree, x);if (node != NULL) {return node->rchild;}return NULL;}//求叶⼦结点数量int leafCount(BinTree *tree) {if (*tree == NULL)return 0;//若左右⼦树都为空则该节点为叶⼦,且后续不⽤接续递归了else if (!(*tree)->lchild && !(*tree)->rchild)return 1;else//若当前结点存在⼦树,则递归左右⼦树, 结果相加return leafCount(&((*tree)->lchild)) + leafCount(&((*tree)->rchild));}//求⾮叶⼦结点数量int NotLeafCount(BinTree *tree) {if (*tree == NULL)return 0;//若该结点左右⼦树均为空,则是叶⼦,且不⽤继续递归else if (!(*tree)->lchild && !(*tree)->rchild)return 0;else//若当前结点存在左右⼦树,则是⾮叶⼦结点(数量+1),在递归获取左右⼦树中的⾮叶⼦结点,结果相加 return NotLeafCount(&((*tree)->lchild)) + NotLeafCount(&((*tree)->rchild)) + 1;}//求树的⾼度(深度)int DepthCount(BinTree *tree) {if (*tree == NULL)return 0;else{//当前节点不为空则深度+1 在加上⼦树的⾼度,int lc = DepthCount(&((*tree)->lchild)) + 1;int rc = DepthCount(&((*tree)->rchild)) + 1;return lc > rc?lc:rc;// 取两⼦树深度的最⼤值 }}//删除左⼦树void RemoveLeft(BinNode *node){if (!node)return;if (node->lchild)DestroyTree(&(node->lchild));node->lchild = NULL;}//删除右⼦树void RemoveRight(BinNode *node){if (!node)return;if (node->rchild)DestroyTree(&(node->rchild));node->rchild = NULL;}int main() {BinTree tree;create(&tree);BinNode *node = Parent(tree, 'G');printf("G的⽗结点为%c\n",node->data);BinNode *node2 = Lchild(tree, 'D');printf("D的左孩⼦结点为%c\n",node2->data);BinNode *node3 = Rchild(tree, 'D');printf("D的右孩⼦结点为%c\n",node3->data);printf("先序遍历为:");PreOrder(tree);printf("\n");printf("中序遍历为:");InOrder(tree);printf("\n");printf("后序遍历为:");PostOrder(tree);printf("\n");printf("层次遍历为:");LevelOrder(tree);printf("\n");int a = leafCount(&tree);printf("叶⼦结点数为%d\n",a);int b = NotLeafCount(&tree);printf("⾮叶⼦结点数为%d\n",b);int c = DepthCount(&tree);printf("深度为%d\n",c);//查找F节点BinNode *node4 = FindNode(tree,'C');RemoveLeft(node4);printf("删除C的左孩⼦后遍历:");LevelOrder(tree);printf("\n");RemoveRight(node4);printf("删除C的右孩⼦后遍历:");LevelOrder(tree);printf("\n");//销毁树printf("销毁树 \n");DestroyTree(&tree);printf("销毁后后遍历:");LevelOrder(tree);printf("\n");printf("Hello, World!\n");return 0;}测试:测试数据为下列⼆叉树:运⾏程序复制粘贴下列内容:ABDGHECKFIJ特别感谢:iammomo。
树与二叉树h
SBNode nodes[MAXSIZE]; } SBTree;
举例
结点 左子
右子
1
26 34
1
2
6
2
3
4
3
0
4
4
0
0
4
4
0
0
特点:
6
0
0
找子方便,找父 结点不便.
三、二叉链表存储结构
第一层 第二层
( A ( B ( E (K,L),F),C(G),D( H (M),I,J )))
第四层 第三层
二、基本术语
结点：包括一个数据元素及若干个指向其它子树 的分支；例如，A，B，C，D等。
叶结点：无后件结点为叶结点；如K，L，M。 根结点：无前件的结点为根；例如，A结点。
子结点：某结点后件为该结点的子结点；例如，
方法描述： 从根结点a开始访问， 接着访问左子结点b， 最后访问右子结点c。
即：
根
A 访问根结点 B 先序遍历左子树 C 先序遍历右子树
a
左子 右子
bc
二、中序法（InOrder）
方法描述：
从左子结点b开始访问，
接着访问根结点a，
最后访问右子结点c。
即：
根
A 中序遍历左子树 B 访问根结点 C 中序遍历右子树
计算机学院
自动化学院
各种社会组织机构；
在计算机领域中，用树表示源
程序的语法结构；
2101 2102
2103
在OS中，文件系统、目录等组
织结构也是用树来表示的。
树-二叉树
信息学奥赛培训之『树——二叉树』树——二叉树为何要重点研究二叉树？ 引 ： 为何要重点研究二叉树 ？ （1）二叉树的结构最简单，规律性最强； （2）可以证明，所有树都能转为唯一对应的二叉树，不失一般性。
一、二叉树基础1. 二叉树的定义 二叉树是一类非常重要的树形结构，它可以递归地定义如下： 二叉树 T 是有限个结点的集合，它或者是空集，或者由一个根结点以及分别称为左 子树和右子树的两棵互不相交的二叉树。
因此，二叉树的根可以有空的左子树或空的右子树，或者左、右子树均为空。
二叉树有 5 种基本形态，如图 1 所示。
图1 二叉树的 5 种基本形态在二叉树中，每个结点至多有两个儿子，并且有左、右之分。
因此任一结点的儿子 不外 4 种情况：没有儿子；只有一个左儿子；只有一个右儿子；有一个左儿子并且有一 个右儿子。
注意：二叉树与树和有序树 的区别 二叉树与度数不超过 2 的树不同，与度数不超过 2 的有序树也不同。
在有序树中，11如果将树中结点的各子树看成从左至右是有次序的，则称该树为有序树，否则称为无序树。
-1-信息学奥赛培训之『树——二叉树』虽然一个结点的儿子之间是有左右次序的，但若该结点只有一个儿子时，就无须区分其 左右次序。
而在二叉树中，即使是一个儿子也有左右之分。
例如图 2-1 中(a)和(b)是两棵 不同的二叉树。
虽然它们与图 2-2 中的普通树(作为无序树或有序树)很相似，但它们却 不能等同于这棵普通的树。
若将这 3 棵树均看作是有序树，则它们就是相同的了。
图2-1 两棵不同的二叉树图2-2 一棵普通的树由此可见，尽管二叉树与树有许多相似之处，但二叉树不是树的特殊情形。
不是 ．．2. 二叉树的性质图3 二叉树性质１： 在二叉树的第 i 层上至多有 2 i −1 结点(i>=1)。
性质２： 深度为 k 的二叉树至多有 2 k − 1 个结点(k>=1)。
性质３： 对任何一棵二叉树 T，如果其终端结点数为 n0,度为 2 的结点数为 n2,则 n0=n2+1。
二叉排序树查找的递归算法
二叉排序树查找的递归算法介绍二叉排序树（Binary Search Tree），也称二叉查找树、有序二叉树或排序二叉树，是一种常用的数据结构。
它具有以下特点：•每个节点都包含一个键值和对应的数据。
•左子树中的所有节点的键值都小于根节点的键值。
•右子树中的所有节点的键值都大于根节点的键值。
•左右子树也分别是二叉排序树。
二叉排序树支持高效的查找、插入和删除操作，其中查找操作是利用递归实现的。
本文将详细介绍二叉排序树查找的递归算法。
二叉排序树的定义二叉排序树的定义如下：class TreeNode:def __init__(self, key, data):self.key = keyself.data = dataself.left = Noneself.right = Noneclass BinarySearchTree:def __init__(self):self.root = None在二叉排序树中，每个节点都是一个TreeNode对象，包含键值key和对应的数据data。
left和right分别指向左子树和右子树的根节点。
树的根节点由BinarySearchTree对象的root属性表示。
二叉排序树查找的递归算法二叉排序树的查找操作是利用递归实现的，其具体算法如下：1.如果待查找的键值等于当前节点的键值，返回当前节点的数据。
2.如果待查找的键值小于当前节点的键值，递归在左子树中查找。
3.如果待查找的键值大于当前节点的键值，递归在右子树中查找。
4.如果在左子树或右子树中找不到对应的键值，则返回空。
下面是二叉排序树查找的递归算法的代码实现：def search_recursive(node, key):if node is None or node.key == key:return node.dataelif key < node.key:return search_recursive(node.left, key)else:return search_recursive(node.right, key)在上述代码中，node表示当前节点，key表示待查找的键值。
查找算法学习常用的查找算法及其时间复杂度
查找算法学习常用的查找算法及其时间复杂度查找算法是计算机科学中非常重要的一种算法，它用于在一组数据中查找指定的元素。
在实际应用中，我们经常需要对大量数据进行查找操作，因此了解不同的查找算法及其时间复杂度对于提高查找效率至关重要。
本文将介绍几种常用的查找算法，并分析它们的时间复杂度。
一、顺序查找算法顺序查找算法是最简单的一种查找算法，也被称为线性查找算法。
它的基本思想是从数据的起始位置开始，一个一个地比较待查找元素和数据中的元素，直到找到匹配的元素或者遍历完所有的元素。
顺序查找算法的时间复杂度为O(n)，其中n表示数据的规模。
由于它需要逐个比较元素，因此在数据规模较大时，效率较低。
二、二分查找算法二分查找算法，也被称为折半查找算法，是一种高效的查找算法。
它的前提是数据必须有序。
基本思想是将待查找的值与中间元素进行比较，如果相等则返回位置，如果不相等则根据大小关系决定继续在左半部分或右半部分进行查找，直到找到匹配的元素或者确定不存在。
二分查找算法的时间复杂度为O(log n)，其中n表示数据的规模。
由于每次查找都将数据规模减半，因此效率非常高。
但是它要求数据必须有序，如果数据无序，需要先进行排序操作。
三、哈希查找算法哈希查找算法是一种常用的查找算法，通过哈希函数将待查找的元素映射到一个桶中，然后在桶中进行查找操作。
它的特点是查找的速度非常快，不受数据规模的影响。
哈希查找算法的时间复杂度近似为O(1)，其中1表示常数时间。
但是它的缺点是需要额外的存储空间来构建哈希表，并且需要解决哈希冲突的问题。
四、二叉查找树算法二叉查找树算法是一种基于二叉树的查找算法，它的特点是左子树的所有节点值小于根节点的值，右子树的所有节点值大于根节点的值。
基于这个特点，可以通过比较待查找元素和当前节点的值来确定查找的方向。
二叉查找树算法的时间复杂度取决于树的高度，如果树的高度为h，则查找的时间复杂度为O(h)。
当二叉查找树退化成链表时，树的高度为n，其中n表示节点的个数，此时查找的时间复杂度为O(n)。
树和二叉树的实验报告
树和二叉树的实验报告树和二叉树的实验报告一、引言树和二叉树是计算机科学中常用的数据结构，它们在各种算法和应用中都有广泛的应用。
本实验旨在通过实际操作和观察，深入了解树和二叉树的特性和操作。
二、树的构建与遍历1. 树的概念和特性树是一种非线性的数据结构，由节点和边组成。
每个节点可以有零个或多个子节点，其中一个节点没有父节点的称为根节点。
树的特点包括层次结构、唯一根节点和无环等。
2. 树的构建在本实验中，我们使用Python语言构建了一棵树。
通过定义节点类和树类，我们可以方便地创建树的实例，并添加节点和连接节点之间的边。
3. 树的遍历树的遍历是指按照一定顺序访问树中的所有节点。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
我们在实验中实现了这三种遍历方式，并观察了它们的输出结果。
三、二叉树的实现与应用1. 二叉树的概念和特性二叉树是一种特殊的树，每个节点最多有两个子节点，分别称为左子节点和右子节点。
二叉树的特点包括唯一根节点、每个节点最多有两个子节点和子节点的顺序等。
2. 二叉树的实现我们使用Python语言实现了二叉树的数据结构。
通过定义节点类和二叉树类，我们可以创建二叉树的实例，并实现插入节点、删除节点和查找节点等操作。
3. 二叉树的应用二叉树在实际应用中有很多用途。
例如，二叉搜索树可以用于实现快速查找和排序算法。
AVL树和红黑树等平衡二叉树可以用于高效地插入和删除操作。
我们在实验中实现了这些应用，并通过实际操作验证了它们的效果。
四、实验结果与讨论通过实验，我们成功构建了树和二叉树的数据结构，并实现了它们的基本操作。
通过观察和分析实验结果，我们发现树和二叉树在各种算法和应用中的重要性和灵活性。
树和二叉树的特性使得它们适用于解决各种问题，例如搜索、排序、图算法等。
同时，我们也发现了一些问题和挑战，例如树的平衡性和节点的插入和删除操作等。
这些问题需要进一步的研究和优化。
五、总结本实验通过实际操作和观察，深入了解了树和二叉树的特性和操作。
《数据结构与算法设计》第5章 树
5.2.2 二叉树的性质
➢ 满二叉树和完全二叉树
满二叉树是指深度为h且节点数取得最大值2h-1的二叉树。 如果一棵深度为h的二叉树，除第h层外，其他每层的节点数 都达到最大，且最后一层的节点自左而右连续分布，这样的二 叉树称为完全二叉树。
5.2.2 二叉树的性质
5.2.2 二叉树的性质
性质6 对含有n个节点的完全二叉树自上而下、同一层从左往右 对节点编号0,1,2,…,n-1，则节点之间存在以下关系： （1）若i=0，则节点i是根节点，无双亲；若i>0，则其双亲节 点的编号为i/2-1； （2）若2×i +1≤n，则i的左孩子编号为2×i+1； （3）若2×i+2≤n，则i的右孩子编号为2×i+2； （4）若i>1且为偶数，则节点i是其双亲的右孩子，且有编号为 i-1的左兄弟； （5）若i<n-1且为奇数，则节点i是其双亲的左孩子，且有编号 为i+1的右兄弟。
5.3.3 二叉树的二叉链表类模板定义
//根据二叉树的先序遍历序列和中序遍历序列创建以r为根的二叉树
void CreateBinaryTree(BTNode<DataType> * &r, DataType pre[], DataType
in[], int preStart, int preEnd, int inStart, int inEnd); int Height(BTNode<DataType> *r); //求以r为根的二叉树高度 //求以r为根的二叉树中叶子节点数目
5.1.2 树的术语
（9）节点的层次：从根节点开始，根为第一层，根的孩子为 第二层，根的孩子的孩子为第三层，依次类推，树中任一节 点所在的层次是其双亲节点所在的层次数加1。 （10）堂兄弟：双亲在同一层的节点互为堂兄弟。
树与二叉树典型例题讲解
A
F
B
J
E
F H
G
I J
例6.14
Huffman编码设计实例
已知某系统在通信联络中只可能出现8种字符，其概率分别为0.05， 0.29，0.07，0.08，0.14， 0.23，0.03，0.11，试设计Huffman编码。 解一：先构造Huffman树，再进行编码。 Huffman编码实现过程：以报文所用的不同字符为叶结点，以字符 出现频率为权重构造Huffman树；然后将树中结点指向其左孩子的 分支标“0”，指向其右孩子的分支标“1”；每个字符的编码即为 从根到每个叶子（字符）的路径上得到的0、1序列。这种对字符的 编码就是Huffman编码。
100
0 1
HC
42
0 1 0
58
1
0
1 2
0 1
1 0
1
0
3
1
1 1 0 0 0
1
1 1 0 1 1
1
1 0 1 1
0
1
23
0
19
1
29
1
29
1
11
0
8 5
14
0
15
1
4 5 6 7 8
1
3 Huffman树
7
8 Huffman编码
解二：利用Huffman编码算法实现。根据题意，取8个字符的权分别为 （5，29，7，8，14，23，3，11），n=8，则m=2*8-1=15，按上述 算法可构造一棵Huffman树，如下左图和右图分别Huffman树的初始 状态和终止状态。
a
b b d g e h i c ^ d c ^
f e ^ g
^ ^ ^
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Swap(hp[c],hp[v]);swap(pos[hp[c]],pos[hp[v]]);
Pop_down(c);
}
}
7. 二叉堆
查找最大值
即根结点——hp[0]
删除元素
将根结点的值改为无穷小并向下调整，总数减一 或者hp[0]=hp[--S]，并向下调整
插入元素
堆的存储方式——数组 C++的选手可以使用Algorithm内的标准的堆 相关函数 E.g. hp[]记录堆元素 pos[]记录元素在堆中位 置 val[]记录元素的权值 元素个数为S 则对于点 v
v-1>>1 其左孩子为 (v<<1)+1 // 若大于S则不存在 其右孩子为 (v<<1)+2 // 若大于S则不存在
其父亲为
7. 二叉堆
调整元素——将一个元素v 的值变大/变小 Pop_down(v) {
Int c = v, i=(v<<1)+1, j=(v<<1)+2; If(i<S&&val[hp[c]]<val[hp[i]])c=I; If( j<S&&val[hp[c]]<val[hp[ j]])c=j; If(c!=v) {
}
U=find(u); v=find(v); If(rank[u]>rank[v]) swap(u,v); Rank[v]+=rank[u]; fst[u]=v;
5. 并查集
思考题：团伙 城市里有N个人，给出M条信息，每条信息告 诉你两个是朋友还是敌人 一个人朋友的朋友是朋友 一个人敌人的敌人还是朋友 请问这个城市里有多少个团伙？ 或者输出不可能 N,M<500000
即将新元素放在序列末尾并向上调整
7. 二叉堆
实用：
Dijkstra算法的优化 很多最值问题 堆排序 ……
7. 二叉堆
思考题：灌水 有N*M个单位方格的土地，每个方格有一个 正的高度，土地周围都是平地。 一天下了大雨，请问这N*M的土地上一共装 了多少水呢？ 你能利用二叉堆和宽度优先遍历设计出时间复 杂度为O(NMlogNM)的算法吗？
6. LCA
LCA(Lowest Common Ancestor) 最近公共祖先问题：
倍增算法O(NlogN)-O(logN)——在线 区间RMQ算法O(NlogN)-O(1)——在线 区间+1RMQ算法O(N)-O(1)——在线 Tarjan算法O(N+Qα(N))-O(1)——离线
i=S;i>=0;--i)
fa[v][0];
7. 二叉堆
堆是一个特殊的二叉树 每个结点有一个权值 根结点的权值不小于其两个孩子结点的权值 支持操作：
O(logN) 删除一个元素 O(logN) 调整一个元素 O(logN) 寻找最大值 O(1)
插入一个元素
7. 二叉堆
3.如何分辨树
关键词
任意两点只有一条路径 平面每个点只向左连一条边 N个点N-1条边的连通图 ……
4.树遍历
先序遍历 中序遍历 后续遍历 层次遍历
对应了搜索问题——搜索问题即在一颗搜索 树上进行遍历
4.1深度优先遍历
分析遍历序列的性质 先序遍历：
aBC
}e[MaxE]; Int head[MaxN], tot; // head初始值为-1 Int Insert(u, v) {
} 遍历： For(int i=head[u];i!=-1;i=e[i].nxt)
Int u, v, nxt; Inline edge(int u=0, int v=0, int nxt=-1):u(u),v(v),nxt(nxt){};
If(P&1<<i) v=fa[v][i];
i=0;i<S;++i)
求公共祖先
For(int
Lca(u, v) {// dep[u]<dep[v]
Go_up(v,dep[v]-dep[u]);
}// O(logN)
Return
If(fa[u][i]!=fa[v][i]) u=fa[u][i],v=fa[v][i];
E[tot]=edge(u,v,head[u]);head[u]=tot++;
5. 并查集
支持操作：
合并两个集合 查找集合的代表元素
实现方式：父亲记录法
用一棵树来表示一个集合 根作为集合的代表元素 合并即将一个集合的根指向另一个集合的根
5. 并查集
优化：
按秩合并
每次总是将点的个数小的那个集合的根指向点数较多的
中序遍历：
BaC
后序遍历： 可以发现在DFS遍历序列中一棵子树必然是连 续一段，因此子树可以和区间相对应
BCa
4.2宽度优先遍历
和图的宽度优先遍历一致 使用队列 优点：
不使用栈空间
速度快 遍历序列即为层次拓扑序列
4.3 树遍历的若干技巧
由于树的稀疏性，请使用邻接表来存储树 邻接表并不需写链表，建议使用数组模拟链表 struct edge {
6.LCA
倍增算法： Dep[v]记录v的深度 Fa[v][k]记录v向上第2k个祖先 预处理：
Fa[v][k]=fa[fa[v][k-1]][k-1]
时空复杂度 O(NlogN)
6.LCA
v向上走p层
For(int
Go_up(&v,p) {
} // O(logN)
那个集合的根
路径压缩
即在寻找根的过程中，将所有指针经过的结点都直接指
向根
5. 并查集
C++代码:fst记录父亲，rank记录点的个数 int find(v) {
} Int unite(int u, int v) {
If(fst[v]==v) return v; Else return (fst[v]=find(fst[v]))
2010山东夏令营
Author : Will
树与二叉树的常用算法
1. 定义
树：要么为空，要么由根结点(root)和n棵子 树组成。 森林：若干棵树 二叉树：递归定义
要么为空，要么由根结点左子树和右子树组成 左右子树都是一颗二叉树
2.树与二叉树的转化
左儿子右兄弟表示法 这样的好处是在很多树形动态规划问题中能大 大降低编程复杂度和算法的时间复杂度