二叉树

定义

二叉搜索树，也称有序二叉树,排序二叉树，是指一棵空树或者具有下列性质的二叉树：
1. 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
2. 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
3. 任意节点的左、右子树也分别为二叉查找树。
4. 没有键值相等的节点。

关于遍历

前序遍历（根-左-右）
中序遍历（左-根-右）
后序便利（左-右-根）

测试代码实现

#include <iostream>
using namespace std;


//定义二叉树节点
typedef struct node
{
    int value;
    struct node* leftChild;
    struct node* rightChild; 
}BinaryTree, *BTptr;


//二叉树中插入元素
int insert(BTptr &p, int value)
{
    int ret = 0;

    //如果是空树，则先初始化
    if(p == NULL){
        p = new BinaryTree;
        p->value = value;
        p->leftChild = NULL;
        p->rightChild = NULL;
        cout << "insert:" << value << endl;        
        return ret;
    }


    if(value < p->value)
        return insert(p->leftChild, value);
    else if(value > p->value)
        return insert(p->rightChild,value);
    else{
        cout << "不能插入重复元素:" << value << endl;
        ret = -1;
    }

    return ret;    

}


void preTraverse(BTptr p)
{
    if(p){
         cout << p->value << endl;
         preTraverse(p->leftChild);
         preTraverse(p->rightChild);
    }
}


void midTraverse(BTptr p)
{
    if(p){
         midTraverse(p->leftChild);
         cout << p->value << endl;
         midTraverse(p->rightChild);
    }
} 

void lstTraverse(BTptr p)
{
    if(p){
         lstTraverse(p->leftChild);
         lstTraverse(p->rightChild);
         cout << p->value << endl;
    }
}

int main(){
    //   
    BinaryTree* bTree = NULL;

    insert(bTree, 0);
    insert(bTree, 2);
    insert(bTree, 1);
    insert(bTree, 6);
    insert(bTree, 4);
    insert(bTree, 5);

    insert(bTree, -3);
    insert(bTree, -2);
    insert(bTree, -5);
    insert(bTree, -6);
    insert(bTree, -4);


     //先序遍历
    cout << "先序遍历:" << endl;
    preTraverse(bTree);

    cout << "中序遍历:" << endl;
    midTraverse(bTree);

    cout << "后序遍历:" << endl;
    lstTraverse(bTree);
    return 0;
}

程序中的二叉树应该如图：

那么几种遍历结果如下：

insert:0
insert:2
insert:1
insert:6
insert:4
insert:5
insert:-3
insert:-2
insert:-5
insert:-6
insert:-4
先序遍历:
0
-3
-5
-6
-4
-2
2
1
6
4
5
中序遍历:
-6
-5
-4
-3
-2
0
1
2
4
5
6
后序遍历:
-6
-4
-5
-2
-3
1
5
4
6
2
0