概念
1、结点的度:结点拥有的子树个数
2、树的度:树内各结点度的最大值
3、叶结点(终端结点):度为0的结点
4、分支结点:度大于0的结点
5、满二叉树:所有的分支结点都存在左右孩子,左右的叶子结点都在同一层的二叉树
6、完全二叉树:对一棵具有n个结点的二叉树按层编号,如果编号为i(1<=i<=n)的结点与同样深度的满二叉树中编号为i的结点中位置完全相同,那此树就是一棵满二叉树(结点只能从左到右,从上往下生长)
7、平衡二叉树:如果某二叉树中任意结点的左右子树的深度相差不超过1 ,那么它就是一棵平衡二叉树
性质
1、在二叉树的第i层最多有2^(i-1)个结点
2、深度为k的二叉树最多有2^k-1个结点
3、对任何一颗二叉树,若有n0个叶结点,度为2的结点数位n2,则n0 = n2 + 1
(树枝数 = n0 + n1 + n2 -1 = n1 + 2*n2)
4、具有n个结点的完全二叉树的深度为[log2n] + 1(2为底,n的对数)
5、对一棵有n个结点的完全二叉树按层编号(从0开始):
A.若 i = 0,则结点 i 为二叉树的根;若 i > 0, 则其双亲为[(i-1) / 2]
B.若 2 * i +1 > n,则结点 i 无左孩子,否则其左孩子是结点 2 * i + 1
C.若 2 * i +2 > n,则结点 i 无右孩子,否则其右孩子是结点 2 * i + 2
遍历二叉树
先序遍历:根左右
先序代码:
void PreOrderTraverse(Node* node){
if(node == NULL) return ;
cout<<node->data<<" ";
PreOrderTraverse(node->lchild);
PreOrderTraverse(node->rchild);
}
中序遍历:左根右
中序代码:
void InOrderTraverse(Node* node){
if(node == NULL) return ;
InOrderTraverse(node->lchild);
cout<<node->data;
InOrderTraverse(node->rchild);
}
后序遍历:左右根
后序代码:
void PostOrderTraverse(Node* node){
if(node == NULL) return ;
PostOrderTraverse(node->lchild);
PostOrderTraverse(node->rchild);
cout<<node->data;
}
层次遍历:从上到下,从左到右
1、把根节点A放入队列,此时队列为:A,队列头指针指向A,也就是队列第一个元素
2、把当前队列头指针所指元素的左右儿子放入队列,即将B C放入队列,此时队列为A B C ,队列头指针向后移一格,此时指向B
3、不断重复2步骤。此时把B的左右儿子取出来放入队尾,队列变为A B C D,
队列头指针后移,指向C。把C的左右儿子取出来放入队尾,队列变为A B C D E F
队列头指针后移,指向D。把D的左右儿子取出来放入队尾,队列变为A B C D E F G H
队列头指针后移,指向E。把E的左右儿子取出来放入队尾,队列变为A B C D E F G H I
4、结束条件,队列头指针和为指针重合时,输出最后一个元素,算法结束!也就是说,把这个队列从头到尾输出一遍,就是按层遍历,这个队列是动态的,只要有子节点,子节点就会不停的加入队尾,但总有子节点没有的时候,所以,队列尾指针肯定有不再移动的时候,而头指针一直在一步一步向下移,总会有首尾指针重合的时候,即标志着算法结束。
层次遍历代码:
void LevelOrderTraverse(Node* root){
if(root == NULL) return ;
queue<Node*> q;
q.push(root);
while(!q.empty()){
cout<<q.front()->data<<" ";
if(q.front()->lchild != NULL){
q.push(q.front()->lchild);
}
if(q.front()->rchild != NULL){
q.push(q.front()->rchild);
}
q.pop();
}
cout<<endl;
}
注:已知中序遍历和先序遍历结果,或已知中序遍历和后序遍历结果可以还原二叉树
二叉树深度
最简单的方式就是使用递归的方式来遍历二叉树,在递归的处理函数中逐渐增加二叉树的深度
int getDeepth(Node* node){
if(node == NULL) return 0;
int left = getDeepth(node->lchild);
int right = getDeepth(node->rchild);
return left>right ? left+1 : right+1;
}
图解(深度为3):
注:‘#’ 表示此结点为空,向调用处返回0,实际的二叉树如下
判断平衡二叉树
递归地检查二叉树中所有结点的左右子树的深度之差,若都相差不超过1 ,那么它就是一棵平衡二叉树
bool isBalanced(Node* node){
if(node == NULL) return true;
int left = getDeepth(node->lchild);
int right = getDeepth(node->rchild);
int gap = abs(left - right);
//对于当前结点而言,左右子树的深度之差大于1,不平衡
if(gap > 1)
return false;
//对于当前结点而言,左右子树的深度只差不大于1,平衡
//接着检查其左右子树是否平衡
return isBalanced(node->lchild) && isBalanced(node->rchild);
}
构造二叉搜索树的insert操作
Node* insert(Node* node, int num){
if(node == nullptr){
node = new Node(num);//当前结点为空,直接构造结点挂上
}else if(node->val > num){
node->left = insert(node->left, num);
}else if(node->val < num){
node->right = insert(node->right, num);
}
//相等直接返回
return node;
}
将有序数组转为二叉搜索树
class Solution {
public:
TreeNode* sortedArrayToBST(vector<int>& nums) {
return getBST(nums, 0, nums.size() - 1);
}
TreeNode* getBST(vector<int>& nums, int l, int r){
if(l > r){
return nullptr;
}
int mid = (l + r) / 2;
TreeNode* node = new TreeNode(nums[mid]);
node->left = getBST(nums, l, mid - 1);
node->right = getBST(nums, mid + 1, r);
return node;
}
};
面向过程完整代码:
#include<iostream>
#include<queue>
using namespace std;
struct Node{
char data;
Node* lchild;
Node* rchild;
}Node;
//按先序输入二叉树结点的值
//根据输入序列创建二叉树
//用双指针是为了将根结点传入,执行函数完成后,还能通过此根结点找到树
void CreateTree(Node** node){
char temp;
cin>>temp;
if(temp == '#')
*node = NULL;
else{
*node = (Node*)malloc(sizeof(Node));
(*node)->data = temp;
CreateTree(&((*node)->lchild));
CreateTree(&((*node)->rchild));
}
}
//先序遍历
void PreOrderTraverse(Node* node){
if(node == NULL) return ;
cout<<node->data<<" ";
PreOrderTraverse(node->lchild);
PreOrderTraverse(node->rchild);
}
//中序遍历
void InOrderTraverse(Node* node){
if(node == NULL) return ;
InOrderTraverse(node->lchild);
cout<<node->data;
InOrderTraverse(node->rchild);
}
//后序遍历
void PostOrderTraverse(Node* node){
if(node == NULL) return ;
PostOrderTraverse(node->lchild);
PostOrderTraverse(node->rchild);
cout<<node->data;
}
void LevelOrderTraverse(Node* root){
if(root == NULL) return ;
queue<Node*> q;
q.push(root);
while(!q.empty()){
cout<<q.front()->data<<" ";
if(q.front()->lchild != NULL){
q.push(q.front()->lchild);
}
if(q.front()->rchild != NULL){
q.push(q.front()->rchild);
}
q.pop();
}
cout<<endl;
}
int getDeepth(Node* node){
if(node == NULL) return 0;
int left = getDeepth(node->lchild);
int right = getDeepth(node->rchild);
return left>right ? left+1 : right+1;
}
bool isBalanced(Node* node){
if(node == NULL) return true;
int left = getDeepth(node->lchild);
int right = getDeepth(node->rchild);
int gap = abs(left - right);
//对于当前结点而言,左右子树的深度之差大于1,不平衡
if(gap > 1)
return false;
//对于当前结点而言,左右子树的深度只差不大于1,平衡
//接着检查其左右子树是否平衡
return isBalanced(node->lchild) && isBalanced(node->rchild);
}
int main(){
Node* root = (Node*)malloc(sizeof(Node));
//测试数据AB#D##C##
cout<<"输入数据:";
CreateTree(&root);
cout<<"先序遍历结果:";
PreOrderTraverse(root);
cout<<endl;
cout<<"中序遍历结果:";
InOrderTraverse(root);
cout<<endl;
cout<<"后序遍历结果:";
PostOrderTraverse(root);
cout<<endl;
cout<<"层次遍历结果:";
LevelOrderTraverse(root);
cout<<"二叉树的深度:";
cout<<getDeepth(root)<<endl;
cout<<"是平衡二叉树吗?"<<isBalanced(root)<<endl;
return 0;
}
运行结果:
注:创建结果如上图(二叉树深度部分的图)
面向对象版完整代码
#include<iostream>
#include<queue>
using namespace std;
typedef struct Node{
char data;
struct Node* lchild;
struct Node* rchild;
}Node;
class Tree{
private:
Node* root;
int tree_deepth;
//先序
void Pre(Node* node){
if(node == NULL) return ;
cout<<node->data<<" ";
Pre(node->lchild);
Pre(node->rchild);
}
//中序
void In(Node* node){
if(node == NULL) return ;
In(node->lchild);
cout<<node->data;
In(node->rchild);
}
//后序
void Post(Node* node){
if(node == NULL) return ;
In(node->lchild);
In(node->rchild);
cout<<node->data;
}
//层次
void Level(Node* node){
if(root == NULL) return ;
queue<Node*> q;
q.push(root);
while(!q.empty()){
cout<<q.front()->data<<" ";
if(q.front()->lchild != NULL){
q.push(q.front()->lchild);
}
if(q.front()->rchild != NULL){
q.push(q.front()->rchild);
}
q.pop();
}
cout<<endl;
}
void CreateTree(Node** node){
char temp;
cin>>temp;
if(temp == '#')
*node = NULL;
else{
*node = (Node*)malloc(sizeof(Node));
(*node)->data = temp;
CreateTree(&((*node)->lchild));
CreateTree(&((*node)->rchild));
}
}
int Deepth(Node* node){
if(node == NULL) return 0;
int left = Deepth(node->lchild);
int right = Deepth(node->rchild);
return left>right ? left+1 : right+1;
}
bool Balanced(Node* node){
if(node == NULL) return true;
int left = Deepth(node->lchild);
int right = Deepth(node->rchild);
int gap = abs(left - right);
//对于当前结点而言,左右子树的深度之差大于1,不平衡
if(gap > 1)
return false;
//对于当前结点而言,左右子树的深度只差不大于1,平衡
//接着检查其左右子树是否平衡
return Balanced(node->lchild) && Balanced(node->rchild);
}
public:
Tree(){
root = (Node*)malloc(sizeof(Node*));
cout<<"输入数据:";
CreateTree(&root);
}
void PreOrderTraverse(){
Pre(root);
}
void InOrderTraverse(){
In(root);
}
void PostOrderTraverse(){
Post(root);
}
void LevelOrderTraverse(){
Level(root);
}
void CountDeepth(){
tree_deepth = Deepth(root);
}
int getDeepth(){
CountDeepth();
return tree_deepth;
}
bool isBalanced(){
return Balanced(root);
}
};
int main(){
//AB#D##C##
Tree tree;
cout<<"先序遍历结果:";
tree.PreOrderTraverse();
cout<<"中序遍历结果:";
tree.InOrderTraverse();
cout<<"后序遍历结果:";
tree.PostOrderTraverse();
cout<<endl;
cout<<"层次遍历结果:";
tree.LevelOrderTraverse();
cout<<"树的深度为:"<<tree.getDeepth()<<endl;
cout<<"是平衡二叉树吗?"<<tree.isBalanced()<<endl;
return 0;
}
线索二叉树
将普通二叉树线索化成中序线索二叉树:
线索二叉树的数据结构:
中序线索二叉树的存储结构:
将普通二叉树线索化成先序线索二叉树:
先序线索二叉树的存储结构:
将普通二叉树线索化成后序线索二叉树:
后序线索二叉树的存储结构:
用两个指针,在中序遍历的同时,将二叉树中序线索化:
中序线索化实现代码:
先序线索化实现代码:
后序线索化实现代码:
注: 只有构造先序线索二叉树时,才需要判断左指针是否是真实的结点。因为先序遍历的顺序是【根,左,右】,访问根结点后可能会线索化左指针。改变左指针后,马上再接着访问当前根结点的左孩子,就会访问到当前根结点的父结点,然后又访问回来…,这样死循环下去。
别的顺序线索化二叉树,不需要判断左指针是否是真实的结点。中序线索化时,先访问左孩子,由于左孩子线索化后,会接着访问根结点,不会再往下层访问,所以线索化对中序遍历没有影响。后序线索化同样的分析。
中序线索化二叉树完整代码:
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
struct TreeNode {
char val;
TreeNode *left;
TreeNode *right;
int ltag;
int rtag;
TreeNode(char x) : val(x), left(nullptr), right(nullptr), ltag(0), rtag(0) {
}
};
TreeNode* buildTree(vector<char>& preorder, vector<char>& inorder) {
if(preorder.size() == 0){
return nullptr;
}
TreeNode* root = new TreeNode(preorder[0]);
auto mid = find(inorder.begin(), inorder.end(), preorder[0]); //指向根结点值的迭代器
char left_nodes = mid - inorder.begin(); //左子树结点数目
vector<char> left_preorder(preorder.begin()+1, preorder.begin()+1+left_nodes);
vector<char> right_preorder(preorder.begin()+1+left_nodes, preorder.end());
vector<char> left_inorder(inorder.begin(), mid);
vector<char> right_inorder(mid+1, inorder.end());
root->left = buildTree(left_preorder, left_inorder);
root->right = buildTree(right_preorder, right_inorder);
return root;
}
void inVisit(TreeNode* cur, TreeNode* &pre){
if(cur->left == nullptr){
cur->left = pre;
cur->ltag = 1;
}
if(pre != nullptr && pre->right == nullptr){
pre->right = cur;
pre->rtag = 1;
}
pre = cur;
}
void inThread(TreeNode* root, TreeNode* &pre){
if(root != nullptr){
inThread(root->left, pre);
inVisit(root, pre);
inThread(root->right, pre);
}
}
TreeNode* getInThreadTree(TreeNode* root){
TreeNode* pre = nullptr;
if(root != nullptr){
inThread(root, pre);
if(pre->right == nullptr){
pre->rtag = 1; //处理遍历的最后一个结点
}
}
return root;
}
int main(){
vector<char> preorder = {'A', 'B', 'D', 'G', 'E', 'C', 'F'};
vector<char> inorder = {'D', 'G', 'B', 'E', 'A', 'F', 'C'};
TreeNode* root = buildTree(preorder, inorder); //构造上图的二叉树
TreeNode* inThreadTree = getInThreadTree(root);
cout<<inThreadTree->right->left->right->val<<endl; //验证线索化是否正确
return 0;
}
树的孩子兄弟表示法:
森林与二叉树相互转换:
先将每棵树按照孩子兄弟表示法转换为二叉树,然后把C、D当作B的兄弟结点,挂到B的后子树上,就像这样:
将二叉树按照孩子兄弟表示法还原为森林:
树的先根遍历
先访问根,在从左往后访问子树
树的后根遍历
先从左往后访问子树,最后访问根
因为树中,不管是左孩子还是右孩子对应到孩子兄弟表示法的二叉树中,都是左孩子。所以树中的【左、右、根】对应成了二叉树中的【左、根】,换到下一颗树遍历时,二叉树就变成了右孩子,故 树的后序遍历 = 对应二叉树的中序遍历
树的层次遍历
森林的遍历
- 森林的先序遍历 = 从左到右对每棵树先序遍历 = 对应二叉树的先序遍历
- 森林的中序遍历 = 从左到右对每棵树后序遍历 = 对应二叉树的中序遍历