关于二叉树的插入和遍历

    在数据结构中，要我选择的话，优先选择C++的容器，出错率小，其次就是二叉树了。至于哈希表这种需要思考一个好的键值的反而最不擅长，本文就讲下二叉树的存储和遍历，直接上代码（话说这个博客的代码编译器真不好用！）。

#include <stdio.h>

#include <stdlib.h>

struct TNode

{

        char data;//这里可以写成struct xxx data，测试就用char类型了

        struct TNode *lchild;

        struct TNode *rchild;//定义节点

};

typedef struct TNode Node;//定义别名

int init(Node **node)// 申请新的节点空间，左右孩子置为NULL,成功为0，失败-1

{

        *node = (Node *)malloc(sizeof(Node));

        if（*node!=0）

        {

                return -1;

        }

        (*node)->lchild = (*node)->rchild = NULL;(*node)->data = 0;

        reuturn 0;

}

int construct(char data, Node **node)//本次的重点，就时把大的数据放在右边，小的放左边，若插入成功返回0，失败-1，这样查找数据时时间复杂度为log2 n次

{int i;

Node *temp_node = *node;

while(temp_node)//判断头节点是否为空，若为空，不进行任何操作

{

                if(!temp_node->data)

                {

                        temp_node->data=data; 

                        return 0;

                }

                else if(data<=temp_node->data)

                {

                        if(!temp_node->lchild)

                        {    

                                if(!init(&temp_node->lchild))

                                {  

                                        temp_node->lchild->data=data;//生成节点插入数据。    

                                        return 0;

                                }

                                else

                                    return -1;

                        }

                        else

                        {

                                temp_node = temp_node->lchild;

                                continue;

                        }

            }    

            else if(data > temp_node->data)

            {

                     if(!temp_node->rchild)

                     {

                              if(!init(&temp_node->rchild))

                              { 

                                      temp_node->rchild->data=data; 

                                       return 0;

                               }

                              else

                                       return -1;

                   }

                   else

                    {     

                           temp_node = temp_node->rchild;    

                           continue;

                     }

                }

       }      

return -1;

}

int preordertraverse(Node *tree_node)//先序遍历

{

        if(tree_node)

       {

            printf("%c ",tree_node->data)；

            if(preordertraverse(tree_node->lchild))

                    if(preordertraverse(tree_node->rchild))

                            return 1;

            return 0;

        }

        else

                return 1;

}

int inordertraverse(Node *tree_node)//中序遍历

{

        if(tree_node)

        {

                if(inordertraverse(tree_node->lchild))

                        printf("%c ",tree_node->data)；

                                if(inordertraverse(tree_node->rchild))

                                         return 1;

              return 0;

        }

        else

                return 1;

}

int postordertraverse(Node *tree_node)//后序遍历

{

         if(tree_node)

        {

                if(postordertraverse(tree_node->lchild))

                        if(postordertraverse(tree_node->rchild))

                        {    

                                printf("%c ",tree_node->data)；

                                return 1;

                        }

                return 0;

        }

        else

                return 1;

}//这三个遍历就是简单的递归调用，区别就是printf在那个位置

int main()

{

        int i;

        Node *root;    

        char data[8] = {'e','f','h','g','a','c','b','d'};

        init(        &root);    

        for(i=0;i<8;i++)

                    construct(data[i],&root);

         pirntf("\npreorder .............\n");

         preordertraverse(root);

         printf("\npostorder ..............\n");

         postordertraverse(root);

         printf("\ninordertraverse ..........\n");

         inordertraverse(root); printf("\n");

        return 0;

}

    这就是笔者二叉树的习惯用法，查找效率比较高，时间复杂度为log2  n次，还是比较好用的，可以当个模板。