小河学习日记之树篇

树相关的额术语：
根：树的最顶层的元素，有且只有一个。
父（双亲）：指的是元素的上一层元素
子：指的是下一层元素
叶子结点：没有子节点的元素，一般在树的最底层
兄弟结点：具有同一个父节点的元素
度：子的数量
层度：树的层数
密度：树的元素个数
结点：一个元素就是一个结点。

普通树：子的个数不确定
普通树的存储：
顺序存储：
1.对结点存储顺序没有要求
2.从上到下，从左到右存储
链式存储：
二叉树：子最多只有两个
普通二叉树：对二叉树的结没有位置和数量上的要求
完全二叉树：除了最后一层，其他层的结点都是2的层数-1次方，最后一层从左到右存储
满二叉树：每一层的节点数量都是2的层数-1次方
有序二叉树：所有的左子结点都小于根节点，所有的右子结点都大于根节点
平衡二叉树：有序二叉树的左右子树高度相差不超过一

相关术语：
遍历：前序（根，左，右），中序（左，根，右），后序（左，右，根），层序（从上到下，从左到 右）；
根据遍历顺序构建二叉树：
前，中，后：前中（以知前序和中序构建二叉树），后中（以知后序和中序构建二叉树）
层序：空位置用#表示

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <math.h>
#define TYPE int
#define NIL 0
typedef struct Node
{
TYPE data;
struct Node* left;
struct Node* right;
}Node;
//创建
Node* creat_node(TYPE data);
//添加
bool add_tree(Node* root,TYPE data);
//删除
bool del_tree(Node* root,TYPE data);
//修改
bool modify_tree(Node* root,TYPE old,TYPE new);
//访问
bool access_tree(Node* root,size_t i,TYPE* p);
//前序
void prev_show(Node* root);
//中序
void in_show(Node* root);
//后序
void post_show(Node* root);
//层序
void level_show(Node* root);
//高度
size_t high_tree(Node* root);

//密度
size_t density_tree(Node* root);

int main()
{
Node* tree=creat_node(50);
for(int i=0;i<10;i++)
{
TYPE data=rand()%100;
printf("%d %s\n",data,add_tree(tree,data)?“成功”:“失败”);
}
prev_show(tree);
printf("\n");
in_show(tree);
printf("\n");
post_show(tree);
printf("\n");
access_tree(tree,6,NULL);
}
//创建
Node* creat_node(TYPE data)
{
Node* node=malloc(sizeof(Node));
node->data=data;
node->left=NULL;
node->right=NULL;
return node;

}

//添加
bool add_tree(Node* root,TYPE data)
{
if(NULLroot)return false;
if(root->data>data)
{
if(root->leftNULL)
{
root->left=creat_node(data);
return true;
}
return add_tree(root->left,data);
}
else
{
if(root->rightNULL)
{
root->right=creat_node(data);
return true;
}
return add_tree(root->right,data);
}
}
//删除,如果根节点允许被删除，需要使用二级指针
bool del_tree(Node* root,TYPE data)
{
if(NULL == root)return false;
if(dataleft->data)
{
if(NULL!=root->left&&data == root->left)
{
Node* node =root->left;
root->left=root->left->left;
_add_tree(root->left,root->right);
free(node);
return true;
}
return del_tree(root->left,data);
}
if(data>root->right->data)
{
if(NULL!=root->right&&data == root->right)
{
Node* node =root->right;
root->left=root->left->left;
_add_tree(root->left,root->right);
free(node);
return true;
}
return del_tree(root->left,data);
}
}
//访问
bool access_tree(Node* root,size_t i,TYPE* p)
{
if(NULL root)return false;
static size_t index;
bool lflag=access_tree(root->left,i,p);
if(iindex && !lflag)
{
printf("%d",root->data);
index =0;
return true;
}
index++;
bool rflag=access_tree(root->right,i,p);
return lflag||rflag;
}
//前序
void prev_show(Node* root)
{
if(NULLroot)return;
printf("%d ",root->data);
prev_show(root->left);
prev_show(root->right);
}
//中序
void in_show(Node* root)
{
if(NULL==root)return;

in_show(root->left);
printf("%d ",root->data);
in_show(root->right);

}
//后序
void post_show(Node* root)
{
if(NULL==root)return;

post_show(root->left);

post_show(root->right);
printf("%d ",root->data);

}
//层序
void level_show(Node* root);

//高度
size_t high_tree(Node* root)
{
if(NULL == root)return 0;
size_t lh=high_tree(root->left);
size_t rh=high_tree(root->right);
return lh>rh?lh+1:rh+1;
}

//密度
size_t density_tree(Node* root)
{
if(NULL == root) return 0;
return 1+density_tree(root->left)+density_tree(root->right);
}