二叉树

二叉树的存储
(1)顺序结构存储就是使用数组来存储只适合表示完全二叉树一般使用数组只适合于完全二叉树(物理上是一个数组,逻辑上是二叉树)-堆
(2)链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系
完全二叉树和满二叉树
(1)完全二叉树:最后一层结点不满上层结点满的树
(2)满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。
二叉树的前中后序遍历
前序创建左右孩子和根排除特殊情况根为空
为根左右的结构根在第一个结点
ypedef struct Node {
struct Node *left;
struct Node *right;
char value;
} Node;

void Preorder(Node *root) {
if (root != NULL) {
printf("%c “, root->value);
Preorder(root->left);
Preorder(root->right);
}
}
中序–为左右根的结构其中根在最中间,左右子树随根节点两边对称
void Inorder(Node *root) {
if (root != NULL) {
Inorder(root->left);
printf(”%c “, root->value);
Inorder(root->right);
}
}
后序:根在最后一个节点
void Postorder(Node *root) {
if (root != NULL) {
Postorder(root->left);
Postorder(root->right);
printf(”%c ", root->value);
}
}
二叉树的结点个数
int GetSize(Node *root) {
if (root == NULL) {
return 0;
}
else {
int left = GetSize(root->left);
int right = GetSize(root->right);

	return left + right + 1;
}

}
二叉树的叶子结点
叶子结点:度为0也就是终端的结点最后一层的结点
int GetLeafSize(Node *root) {
if (root == NULL) {
return 0;
}
else if (root->left == NULL && root->right == NULL) {
return 1;
}
else {
return GetLeafSize(root->left) + GetLeafSize(root->right);
}
}
二叉树的高度—(左右子树哪个高 则是哪个子树+1)
int GetHeight(Node *root) {
if (root == NULL) {
return 0;
}
else {
// 不要多次用同样的参数调用函数
int left = GetHeight(root->left) + 1;
int right = GetHeight(root->right) + 1;
return (left > right ? left : right);
}
}
求第k层的结点个数
(1)特殊情况处理为空和只为一层的情况
(2)k层等于左边子树和右边子树当前层的节点数的和
if (root == NULL) {
return 0;
}
else if (k == 1) {
return 1;
}
else {
int left = GetKLevelSize(root->left, k - 1);
int right = GetKLevelSize(root->right, k - 1);
return left + right;
}
}
二叉树的查找
普通二叉树的查找 如果找到了，返回 v 所在结点的地址如果没找到，返回 NULL(1)先去根里找 如果没找到(2)再去左子树找如果还没找到(3)再去右子树找, 在空树里找的结果，一定找不到，return NULL
Node * Find(Node *root, char v) {
if (root == NULL) {
// 空树
return NULL;
}
else if (root->value == v) {
// 根就是
return root;
}

Node *node = Find(root->left, v);
if (node != NULL) {
	return node;
}
node = Find(root->right, v);
if (node != NULL) {
	return node;
}
else {
	return NULL;
}

}
检测两个树是否相同
(1)特殊情况处理两个树同时为空和两个树右一个为空(2)遍历左右子树两个树的左右子树分别相等才相等
bool isSame(Nodep, Nodeq) {
if (p == NULL && q == NULL) {
return true;
}
if (p == NULL || q == NULL) {
return false;
}
return p->value == q->value
&& isSame(p->left, q->left)
&& isSame(p->right, q->right);
}
判断一个二叉树是否是另一个二叉树的子树
(1)判断两个树是否一样—因为两个树一样是一个子树的特殊情况
(2)前序递归遍历判断—左子树相同或者右子树形态也是子树,如果都不符合则不是子树
bool preorder(Noderoot, Nodet) {
if (root != NULL) {
// 根
if (isSame(root, t)) {
return true;
}
if (preorder(root->left, t) == true) {
return true;
}
return preorder(root->right, t);
}
return false;
}
bool isSubtree(Node* s, Node* t) {
return preorder(s, t);
}
如何前序构建一个二叉树
(1)前序构建

typedef struct Node {
struct Node *left;
struct Node *right;
char value;
} Node;
(1)特殊情况处理size=0或者前序的为0都表示为空节点
(2)左子树用掉的结点=CreateTree1(preorder+1, size-1, leftused)
CreateTree前序遍历从1开始下标为0为root,所以size-1,(去掉根)
(4)右子树用掉的结点=CreateTree1( preorder+1+leftused, size-1-leftused, rightused)
总共用掉的节点树=左边用掉+右边用掉+根
Node * CreateTree1(char preorder[], int size, int *used) {
if (size == 0) {
*used = 0;
return NULL;
}
if (preorder[0] == ‘#’) {
*used = 1;
return NULL;
}
Node *root = malloc(sizeof(Node));
root->value = preorder[0];
int leftUsed;
root->left = CreateTree1(preorder + 1, size - 1, &leftUsed);
int rightUsed;
root->right = CreateTree1(
preorder + 1 + leftUsed,
size - 1 - leftUsed,
&rightUsed);
*used = 1 + leftUsed + rightUsed;
return root;
}
(2)前序+中序
前序ABDEHCFG
中序DBEHAFCG
后序DHEBFGCA
(2.1)采用前序+中序
(2.1.1)特殊情况处理个数为0
(2.1.2)定义查找到的值
(2.1.3)根的值为前序的第一个下标为0,左边子树的个数为=Find(inorder, size, rootValue);就是中序的左边,
find就是以中序为结束数组的位置,那么当中序走完就可以确定左边子树的个数
所以左子树就等于= buildTree(preorder + 1, inorder, leftSize),左子树的开始是前序的第一个位置,中序的第0个位置,个数为leftsize
右子树就等于= buildTree(preorder + 1 + leftSize,
inorder + leftSize + 1, size - 1 - leftSize);
右子树开始的位置就是前序的第一个位置+左子树的个数,中序的最中间的右边就是中序开始的位置+左边子树的个数+根,右子树的个数=size-1(根)-leftsize(左子树)
int Find(char array[], int size, char v) {
for (int i = 0; i < size; i++) {
if (array[i] == v) {
return i;
}
}
return -1;
}
Node * buildTree(char preorder[], char inorder[], int size) {
if (size == 0) {
return NULL;
}
char rootValue = preorder[0];
int leftSize = Find(inorder, size, rootValue);
// 根
Node *root = (Node *)malloc(sizeof(Node));
root->value = rootValue;
// 左子树
root->left = buildTree(preorder + 1, inorder, leftSize);
// 右子树
root->right = buildTree(preorder + 1 + leftSize,
inorder + leftSize + 1, size - 1 - leftSize);
return root;
}
(3)后序+中序
leftSize = Find2(inorder, size, rootValue);–通过中序求左子树的个数
root->left = buildTree2(inorder, postorder, leftSize);
//左子树=后序开始+中序开始+左子树的个数
root->right = buildTree2(inorder + leftSize + 1,
postorder + leftSize, size - 1 - leftSize);
右子树递归=中序的开始+左边子树的个数+根就是(右子树的开始)+后序的开始(后序的开始+左子树的个数),大小依然是size-根-左子树的个数

Node * buildTree2(char inorder[], char postorder[], int size) {
if (size == 0) {
return NULL;
}
char rootValue = postorder[size - 1];
int leftSize = Find2(inorder, size, rootValue);
Node *root = (Node *)malloc(sizeof(Node));
root->value = rootValue;
root->left = buildTree2(inorder, postorder, leftSize);
root->right = buildTree2(inorder + leftSize + 1,
postorder + leftSize, size - 1 - leftSize);
return root;
}
前序+后序无法构建,无法找到左右子树,前序后序找根最方便,中序分割左右子树
二叉树的层序遍历
一层一层的走 (1)先让根入队(2)根带入两个左右孩子
用队列实现
(1)特殊情况为空
(2)启动,
void LevelOrder(Node *root) {
if (root == NULL) {
cout<<endl;
}
// 启动
std::queue<Node *> q;
q.push(root);
while (!q.empty()) {
Node *front = q.front();
q.pop();
cout<value<<endl;
if (front->left != NULL) {
q.push(front->left);
}
if (front->right != NULL) {
q.push(front->right);
}
}
cout<<endl;
}
判断二叉树是否为完全二叉树
用队列实现如果队列最终为空则说明是完全二叉树如果不为空则是不完全二叉树
bool IsComplete(Node *root) {
std::queue<Node *> q;
q.push(root);
while (true) {
Node *front = q.front();
q.pop();
if (front == NULL) {
break;
}
// 层序遍历，空结点也进队列
q.push(front->left);
q.push(front->right);
}
// 判定队列中剩余数据是否全是 NULL
while (!q.empty()) {
Node *front = q.front();
q.pop();
if (front != NULL) {
return false;
}
}
return true;
}
非递归实现前序中序和后序—自定义的栈+循环
void PreOrderNoR(Node *root) {
std::stack<Node *> s;
Node *cur = root;
while (cur != NULL || !s.empty()) {
while (cur != NULL) {
printf("%c “, cur->value);
s.push(cur);
cur = cur->left;
}
Node *top = s.top(); s.pop();
cur = top->right;
}
}
void InOrderNoR(Node *root) {
std::stack<Node *> s;
Node *cur = root;
while (cur != NULL || !s.empty()) {
while (cur != NULL) {
s.push(cur);
cur = cur->left;
}
Node *top = s.top(); s.pop();
printf(”%c “, top->value);
cur = top->right;
}
}
void PostOrderNoR(Node *root) {
std::stack<Node *> s;
Node *cur = root;
Node *last = NULL;
while (cur != NULL || !s.empty()) {
while (cur != NULL) {
// 第一次遇到
s.push(cur);
cur = cur->left;
}
Node *top = s.top();
// 我不知道是第二次遇到还是第三次遇到
if (top->right == NULL) {
printf(”%c “, top->value);
s.pop();
last = top;
}
else if (top->right == last) {
printf(”%c ", top->value);
s.pop();
last = top;
}
else {
cur = top->right;
}
}
}