二叉树操作总结

关于树及二叉树的基本定义就不多说，下面以BST为例，介绍一下二叉树的创建、遍历以及一些简单的算法。

首先是结点定义及初始化：

struct node{
int data;
node* lchild;
node* rchild;
};

node* init_node(int value){
node* new_node = new node();
new_node->data = value;
new_node->lchild = NULL;
new_node->rchild = NULL;
return new_node;
}

还是那句话，初始化别放在main函数中，关于这个问题，程序员们肯定说这还用说吗，但对于没写过程序的人（例如我）来说，可能根本就不会想到这是个问题。

关于BST，咱都知道，即root->data > root->lchild->data && root->data < root->rchild->data; 那么在加入新结点时只需要根据这个条件找到它的父节点即可。

所以，找到要插入结点的父节点并插入的方法如下：

node* search_parent(node* root,int value){
node* parent = root;
node* current_node = root;
while(current_node!=NULL){
parent = current_node;
if(current_node->data >= value){
current_node = current_node->lchild;
}else{
current_node = current_node->rchild;
}
}
return parent;
}
void add_node(node* root,int value){
node* new_node = init_node(value);
node* parent = search_parent(root,value);
if(value >= parent->data){
parent->rchild = new_node;
}else{
parent->lchild = new_node;
}
}

好，下面初始化一个BST并且遍历它，关于二叉树的遍历方式，前序中序后序

node* init_BST(int* arr,int len){
node* root = init_node(9);
for(int i=0;i<len;i++){
add_node(root,arr[i]);
}
return root;
}
void inorder(node* root){
if(root){
inorder(root->lchild);
cout<<root->data<<" ";
inorder(root->rchild);
}
}
void preorder(node* root){
if(root){
cout<<root->data<<" ";
preorder(root->lchild);
preorder(root->rchild);
}
}
void postorder(node* root){
if(root){
postorder(root->lchild);
postorder(root->rchild);
cout<<root->data<<" ";
}
}

下面来考虑几个有关二叉树的算法

1.求叶子结点数

叶子结点既没有左子树也没有右子树，因此只要满足current->lchild==NULL && current->rchild==NULL; 则count+=1;

总的叶子结点数 = l_叶子结点数 + r_叶子结点数，代码如下：

int leaf_node(node* root){
node* current_node = root;
if(current_node==NULL)
return 0;
else if(current_node->lchild==NULL && current_node->rchild==NULL){
cout<<endl<<"leaf node is "<<current_node->data<<" ";
return 1;
}
else
return leaf_node(current_node->lchild)+leaf_node(current_node->rchild);
}

2.求树的高度

数据结构书中给出的算法是

if(root == NULL)

　　height = 0;

else

　　height = max(height(root->lchild),height(root->rchild))+1

由于是求子树的高度，要知道height（root），只需知道height（root->lchild）和height（root->rchild）,同理，要知道height（root->lchild）和height（root->rchild）,只需知道它们各自子树的高度，依次类推。这样的想法，用递归来实现，递归退出的条件为urrent_node->lchild==NULL && current_node->rchild==NULL

int height(node* root){
int lheight,rheight;
node* current_node = root;
if(current_node==NULL)
return 0;
else if(current_node->lchild==NULL && current_node->rchild==NULL)
return 1;
else{
lheight = height(current_node->lchild);
rheight = height(current_node->rchild);
}
int height = lheight>=rheight?lheight+1:rheight+1;
cout<<endl<<"height of child tree "<<height<<" ";
return height;
}

3.查找一个结点

这个也不难想，current_node->data = value,

bool search_node(node* root,int value){
node* current_node = root;
bool has = false;
if(root==NULL){
return false;
}else if(root->data==value){
return true;
}else{
if(root->lchild!=NULL){
has = search_node(root->lchild,value);
}
if(!has && root->rchild!=NULL){
has = search_node(root->rchild,value);
}
}
return has;
}

4.求结点之间的最大路径

这道题目需要考虑三种情况：

（1）root->lchild!=NULL && root->rchild!=NULL

那么距离最远的两个结点一定分别位于左右子树

（2）当没有左子树或者没有右子树时，最大距离可能为某一结点到root根结点之间的距离

（3） 也可能为子树内部的两个结点之间的距离

我第一次写这个题目时，没有考虑那么多，只写出了第一种情况下的代码，如下：

int distance_differentChild(node* root){
int distance;
if((root==NULL)||(root->lchild==NULL&&root->rchild==NULL))
return 0;
else{
distance = height(root->lchild)+height(root->rchild);
}
return distance;
}

当然了，还需要考虑缺了一个子树时的情况，代码如下：

int distance_compare(node* root){
int distance_passroot = height(root);
int distance_notpassroot = distance_differentChild(root);
return distance_passroot>=distance_notpassroot?distance_passroot:distance_notpassroot;
}

最后，汇总一下求最远距离的代码：

int distanceBetweenTwoNodes(node* root){
int distance;
if((root==NULL)||(root->lchild==NULL&&root->rchild==NULL))
return 0;
else if(root->lchild==NULL || root->rchild==NULL){
if(root->lchild!=NULL){
distance = distance_compare(root->lchild);
}
if(root->rchild!=NULL){
distance = distance_compare(root->rchild);
}
}
else{
distance = distance_differentChild(root);
}
return distance;
}