二叉树

一、前序遍历（先根遍历），中序遍历，后序遍历，是根据根节点的位置来区分的。

编码：

typedef struct TREE_NODE
{
TREE_TYPE value;
struct TREE_NODE *left;
struct TREE_NODE *right;
}treeNode,*treeNodeP;

1、前序遍历首先访问根结点然后遍历左子树，最后遍历右子树。

void pre_order(TreeNode * Node)

{

if(Node != NULL){

printf("%d ", Node->data);
pre_order(Node->left);
pre_order(Node->right);
}}
2、中序遍历首先遍历左子树，然后访问根结点，最后遍历右子树。

void middle_order(TreeNode * Node)
{
if(Node != NULL)
{
middle_order(Node->left);
printf("%d ", Node->data);
middle_order(Node->right);
}}
3、后序遍历首先遍历左子树，然后遍历右子树，最后访问根结点，在遍历左、右子树时，仍然先遍历左子树，然后遍历右子树，最后遍历根结点

void post_order(TreeNode * Node)
{
if(Node != NULL)
{
post_order(Node->left);
post_order(Node->right);
printf("%d ", Node->data);
}}

二、二叉搜索树节点数量

int countNodes(treeNode *tree)

{

    if(tree==NULL)

        return 0;

    return 1+countNodes(tree->left)+countNodes(tree->right);

}

三、

1、广度优先搜索，从根节点开始，从左至右搜索第二层，然后第三层。直到检查了所有的节点或者找到了要搜索的节点为止，一个需要额外的内存保存正在搜索的那一层所有节点的子节点。

2、深度优先搜索，跟随树的一个节点向下，在找到节点或到达结束前一直向下搜索，当搜索不能继续向下时，返回最近的祖先，然后继续。

四、其他二叉树函数

#include "tree.h"
#include "assert.h"
#include "stdio.h"
#include "malloc.h"
//插入函数
int insertTreeNode(treeNodeP *root,TREE_TYPE value)
{
treeNodeP current;
treeNodeP *link;
link=root;
if(*root==NULL)//判断第一个根节点是否为空
{
current=malloc(sizeof(treeNode));
assert(current!=NULL);
current->value=value;
current->left=NULL;
current->right=NULL;
*root=current;
return 1;
}
while((current=*link)!=NULL&&value!=current->value)
{
if(value<current->value)
{
link=&current->left;
}
else
{
link=&current->right;
}
}
if(current==NULL)
{
current=malloc(sizeof(treeNode));
assert(current!=NULL);
current->value=value;
current->left=NULL;
current->right=NULL;
*link=current;//这里是将之前找到的位置（左子树或者右子树地址处存储的内容）赋值上新的插入的结点
}
else
{
return 0;
}
return 1;
}
//查找函数
treeNodeP findValue(treeNodeP root,TREE_TYPE value)
{
treeNodeP current;
current=root;
while(current!=NULL&&value!=current->value)
{
if(value<current->value)
{
current=current->left;
}
else
{
current=current->right;
}
}
if(current!=NULL)
{
return current;
}
else
{
return NULL;
}
}
//遍历函数，前序遍历
void preOrderTraverse(treeNodeP root,void (*printfTreeValue)(TREE_TYPE value))
{
if(root!=NULL)
{
printfTreeValue(root->value);
preOrderTraverse(root->left,printfTreeValue);
preOrderTraverse(root->right,printfTreeValue);
}
}

//删除所有节点，和后序遍历是一样的。
DeleteAllNodes(Node *root) {
    if (root == NULL) {    // 空子树，直接返回
        return;
    }
    else {      // 非空子树
        DeleteAllNodes(root->left);   // 删除左子树
        DeleteAllNodes(root->right);  // 删除右子树
        free(root);                   // 释放根节点
    }
}

//找到最近的共同祖先，方法是，这两个值得祖先值一定是介于这两个值之间的。
node findLowestCommonAncestor(node root, int value1, int value2){

while(root!=NULL){

int value=root.getvalue();

if(value>value1&&value>value2){

root=root.getLeft();

else if(value<value1&&value<value2){

root=root.getRight();

else{

return root;

}}

return null;}