目录
一、树
概念
树是一种非线性的数据结构，它是由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
堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点
节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
森林：由m（m>0）棵互不相交的树的集合称为森林；
结构
树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的了解其中最常用的孩子兄弟表示法。
typedef int DataType;
struct Node
{
struct Node* firstchild; //第一个孩子的结点
struct Node* nextbrother; //指向下一个兄弟结点
DataType data; //结点中的数据
};
二、二叉树
概念
一棵二叉树是结点的一个有限集合，该集合:
- 或者为空
- 由一个根节点加上两棵别称为左子树和右子树的二叉树组成
- 二叉树不存在度大于2的结点
- 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
注意：对于任意的二叉树都是由一下集中情况复合而成的
两种特殊的二叉树
1.满二叉树
一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。
2.完全二叉树
完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
性质
- 若规定根节点的层数为1，则一颗非空二叉树的第 i 层上最有多2^(i - 1)个结点
- 若规定根结点的层数为1，则深度为 h 的二叉树的最大结点数为2^h - 1
- 对任何一颗二叉树，如果度为 0 其叶结点个数为n0，度为2的分支结点个数n2，则有n0 = n2 + 1
度为0的用于比度为2的多一个，后续每增加一个度为2，就会增加一个度为0 - 若规定根节点的层数为1，具有n个结点的满二叉树，h = log2 (n+1)
- 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有结点从0开始编号，则对于序号为 i 的结点有：
若 i > 0，i 位置结点的双亲序号：( i - 1 ) / 2，i 为根节点编号，无双亲双点
若 2i + 1 < n，左孩子序号为：2i + 1
若 2i + 2 < n，右孩子序号： 2i + 2
练习
1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ ）
A 不存在这样的二叉树
B 200
C 198
D 199
n0 = n2 + 1
n2 = 199
n0 = 200
选 B
2.下列数据结构中，不适合采用顺序存储结构的是（ ）
A 非完全二叉树
B 堆
C 队列
D 栈
选 A
3.在具有 2n 个结点的完全二叉树中，叶子结点个数为（ ）
A n
B n+1
C n-1
D n/2
2n = n0 + n1 + n2
n0 = n2 + 1
2n = 2n0 + n1 - 1
完全二叉树，最多只有一个度为1的结点
n1 = 1
n0 = n
选 A
4.一棵完全二叉树的节点数位为531个，那么这棵树的高度为（ ）
A 11
B 10
C 8
D 12.
h = log2(n+1)
选 B
5.一个具有767个节点的完全二叉树，其叶子节点个数为（）
A 383
B 384
C 385
D 386
767 = n0 + n1 + n2
n2 = n0 - 1
完全二叉树，最多只有一个度为1的结点
768 = 2n0 + n1
n1 = 0
n0 = 384
选 B
存储结构
二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。
顺序存储
顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储，关于堆我们后面的章节会专门讲解。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。
链式存储
二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链，后面课程学到高阶数据结构如红黑树等会用到三叉链。
typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{
struct BinTreeNode* _pLeft; // 指向当前节点左孩子
struct BinTreeNode* _pRight; // 指向当前节点右孩子
BTDataType _data; // 当前节点值域
}
// 三叉链
struct BinaryTreeNode
{
struct BinTreeNode* _pParent; // 指向当前节点的双亲
struct BinTreeNode* _pLeft; // 指向当前节点左孩子
struct BinTreeNode* _pRight; // 指向当前节点右孩子
BTDataType _data; // 当前节点值域
}；
顺序结构及实现
普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。
链式结构及实现
二叉树是：
- 空树
- 非空：根节点，根节点的左子树、根节点的右子树组成的
从概念中可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照该概念实现的。
结构
#include <stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef char BTDataType;
typedef struct BinaryTreeNode
{
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
BTDataType data;
}BTNode;
创建结点
BTNode* BuyNode(BTDataType x)
{
BTNode* node = (BTNode*)malloc(sizeof(BTNode));
if(node == NULL)
{
printf("malloc failed\n");
eixt(-1);
}
node->data = x;
node->left = node->right = NULL;
return node;
}
BTNode* CreatBinaryTree()
{
BTNode* nodeA = BuyNode('A');
BTNode* nodeB = BuyNode('B');
BTNode* nodeC = BuyNode('C');
BTNode* nodeD = BuyNode('D');
BTNode* nodeE = BuyNode('E');
BTNode* nodeF = BuyNode('F');
nodeA->left = nodeB;
nodeA->right = nodeC;
nodeB->left = nodeD;
nodeC->left = nodeE;
nodeC->right = nodeF;
return nodeA;
}
链式结构的遍历
所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。
访问结点所做的操作依赖于具体的应用问题。
遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算的基础。
前序/中序/后序的递归结构遍历：是根据访问结点操作发生位置命名
- NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
根 左子树 右子树
A B D NULL NULL NULL C E NULL NULL F NULL NULL - LNR：中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
左子树 根 右子树 想要访问根就要先访问根的左子树
NULL D NULL B NULL A NULL E NULL C NULL F NULL - LRN：后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。
左子树 右子树 根 想要访问根就要先访问根的左右子树
NULL NULL D NULL B NULL NULL E NULL NULL F C A
前序遍历
void PreOrder(BTNode* root)
{
if(root == NULL)
{
printf("NULL ");
return;
}
printf("%c ",root->data);
PreOrder(root->left);
PreOrder(root->right);
}
中序遍历
void InOrder(BTNode* root)
{
if(root == NULL)
{
printf("NULL ");
return;
}
InOrder(root->left);
printf("%c ",root->data);
InOrder(root->right);
}
后序遍历
void PostOrder(BTNode* root)
{
if(root == NULL)
{
printf("NULL ");
return;
}
PostOrder(root->left);
PostOrder(root->right);
printf("%c ",root->data);
}
节点个数以及高度等
二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
return root == NULL?0:BinaryTreeSize(root->left)+BinaryTreeSize(root->right) + 1
}
二叉树叶子节点个数
void BinaryTreeLeafSize(BTNode* node)
{
if(root == NULL)
reutnr 0;
else if(root->left == NULL && root->right == NULL)
return 1;
return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}
二叉树第k层节点个数
int Binary TreeLeavlKsize(BTNode* root,int k)
{
assert(k >= 1);
if(root == NULL)
return 0;
if(k == 1)
return 1;
//root不为空，k也不为1，说明root这棵树的第k层节点在子树里面
//转换成左右子树的第k-1等的节点数量
return BinaryTreeLevelKsize(root->left,k-1) + BinaryTreeLevelKsize(root->rgiht,k-1);
}
二叉树深度
int BinaryTreeDepth(BTNode* root)
{
if(root == NULL)
return 0;
int leftDepth = BinaryTreeDepth(root->left);
int rightDepth = BinaryTreeDepth(root->right);
return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root,BTDataType x)
{
if(root == NULL)
return NULL;
if(root->data == x)
return root;
BTNode* leftret = BinaryTreeFind(root->left,x);
if(leftret)
return leftret;
BTNode* rightret = BinaryTreeFind(root->right,x);
if(rightret)
return rightret;
}
练习题
1.单值二叉树
bool isUnivalTree(struct TreeNode* root)
{
if(root == NULL)
return true;
if(root->left && root->left->val != root->val)
return false;
if(root->right && root->right->val != root->val)
reutnr false;
return isUnivalTree(root->left) && isUnivalTree(root->right);
}
2.二叉树最大深度
int BinaryTreeDepth(BTNode* root)
{
if(root == 0)
return 0;
int leftDepth = BinaryTreeDepth(root->left);
int rightDpeth = BinaryTreeDepth(root->right);
return leftDepth > rightDepth ? leftDepth+1 : leftDepth+1;
}
3.检查两棵树是否相同
bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
//两个都为空
if(p == NULL && q == NULL)
return true;
if(p == NULL || q == NULL)
return false;
if(p->val != q->val)
return false;
return isSameTree(p->left,q->left) && isSameTree(p->right,q->right)
}
4.对称二叉树
bool _isSymmetric(struct TreeNode* root1,struct TreeNode* root2)
{
//两个都为空
if(root1 == NULL && root2 == NULL)
return true;
//其中一个为空
if(root1 == NULL || root2 == NULL)
return false;
//两个都不为空
if(root1->val != root2->val)
return false;
return _isSymmetric(root1->left,root2->right) && _isSymmetric(root1->right,root2->left);
}
bool isSymmetric(struct TreeNode* root)
{
if(root == NULL)
return true;
return _isSymmetric(root->left,root->right);
}
5.二叉树的前序遍历
int TreeSize(struct TreeNode* root)
{
return root == NULL?0:TreeSize(root->left)+TreeSize(root->right)+1;
}
void _preorderTraversal(struct TreeNode* root,int* a,int* pi)
{
if(root == NULL)
return;
a[(*pi)++] = root->val;
_preorderTraversal(root->left,a,pi);
_preorderTraversal(root->right,a,pi);
}
int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
int size = TreeSize(root);
int* a = (int*)malloc(size*sizeof(int));
int i = 0;
_preorderTraversal(root,a,&i);
*returnSize = size;
return a;
}
6.另一颗树的子树
bool isSameTree(struct TreeNode* root,struct TreeNode* subRoot)
{
//两个都为空
if(root == NULL && subRoot == NULL)
return true;
//其中一个为空
if(root == NULL || subRoot == NULL)
return false;
if(root->val != subRoot->val)
return false;
return isSameTree(root->left,subRoot->left) && isSameTree(root->right,subRoot->right);
}
bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot)
{
if(root == NULL)
return false;
if(isSameTree(root,subRoot))
return true;
return isSubtree(root->left,subRoot) || isSubtree(root->right,subRoot);
}
3276
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
