C++二叉树结构的建立与基本操作

// Binary_tree.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

#include <stdio.h>

#include <stdlib.h>

#include <iostream>

#include <algorithm>

using namespace std;

typedef int ElemType;

//typedef char ElemType;

typedef struct TreeNode_s

{

    ElemType Data;

    struct TreeNode_s *pLeft;

    struct TreeNode_s *pRight;

}*Ptree,Btree;

//二叉树的创建

Btree * CreateBiTree(Btree *root, ElemType data)

//void  CreateBiTree(Btree *root, ElemType data)

{

    Btree* pNewNode = NULL;

    pNewNode = new Btree;

    pNewNode->Data = data;

    pNewNode->pLeft = NULL;

    pNewNode->pRight = NULL;

    if (root == NULL)

    {

        root = pNewNode;

        return root;

    }

    else

    {

        Btree* pBackNode = NULL;

        Btree* pCurrentNode = root;

        while(pCurrentNode != NULL)

        {

            pBackNode = pCurrentNode;

            //cout << pCurrentNode->Data<<endl;

            if(pCurrentNode->Data > data) //查找左子树

            {

                pCurrentNode = pCurrentNode->pLeft;

            }

            else if (pCurrentNode->Data < data) //查找右子树

            {

                pCurrentNode = pCurrentNode->pRight;

            }

            else

            {

                delete pNewNode;

                return pCurrentNode;

            }

        }

        //cout << pBackNode->Data<<endl;

        //比较插入数据与当前叶子节点，如果大于插入左子树，否则插入右子树

        if (pBackNode->Data > data)

        {

            pBackNode->pLeft = pNewNode;

        }

        else

        {

            pBackNode->pRight = pNewNode;

        }

        return pNewNode;

    }

}

//清空二叉树

void ClearBiTree(Btree* pTreeNode)

{

    if (pTreeNode)

    {

        ClearBiTree(pTreeNode->pLeft);  //清空左子树

        ClearBiTree(pTreeNode->pRight); //清空右子树

        delete pTreeNode;               //释放当前节点所占用的内容

    }

}

//计算二叉树的个数

int BiTreeCount(Btree *root)

{

    if (root == NULL)

    {

        return 0;

    }

    else

    {

        return BiTreeCount(root->pLeft) + BiTreeCount(root->pRight) + 1;

    }

}

//打印二叉树

void PrintBiTree(Btree *root)

{

    Btree *pNode = root;

    if (pNode != NULL)

    {

        cout<<pNode->Data<< " ";

        PrintBiTree(pNode->pLeft);

        PrintBiTree(pNode->pRight);

    }

}

//查找节点，返回该数据所在节点的指针

Btree* FindTreeNode(Btree *root, ElemType data)

{

    Btree *pNode = root;

    if(pNode == NULL)

    {

        return NULL;

    }

    else

    {

        //查找节点，返回该数据所在节点的指针

        if (pNode->Data == data)

        {

            return pNode;

        }

        else

        {          

            if (data < pNode->Data ) //左子树递归查找

            {

                return FindTreeNode(pNode->pLeft, data);

            }

            else if (data > pNode->Data)  //右子树递归查找

            {

                return  FindTreeNode(pNode->pRight,data);

            }

            else

            {

                return NULL;

            }

        }

    }

}

//查找叶子节点

int FindLeafNodeNum(Btree* root)

{

    static int n = 0;

    Btree *pTreeNode = root;

    if (pTreeNode == NULL)

    {

        return 0;

    }

    else

    {

        if (pTreeNode->pLeft == NULL

            && pTreeNode->pRight == NULL)

        {

            n += 1;

        }

        else

        {

            FindLeafNodeNum(pTreeNode->pLeft);

            FindLeafNodeNum(pTreeNode->pRight);

        }

        return n;

    }

}

//先序遍历二叉树:先访问根，然后遍历左子树，再遍历右子树

void PreOrderBiTree(Btree* root)

{

    Btree* pTreeNode = NULL;

    pTreeNode = root;

    if (pTreeNode ==  NULL)

    {

        return ;

    }

    else

    {

        cout << pTreeNode->Data << " ";

        PreOrderBiTree(pTreeNode->pLeft);

        PreOrderBiTree(pTreeNode->pRight);

    }

}

//中序遍历二叉树:先遍历左子树，然后节点数据域，再遍历右子树

void InOrderBiTree(Btree* root)

{

    Btree* pTreeNode = NULL;

    pTreeNode = root;

    if(pTreeNode == NULL)

    {

        return ;

    }

    else

    {

        InOrderBiTree(pTreeNode->pLeft);

        cout << pTreeNode->Data << " ";

        InOrderBiTree(pTreeNode->pRight);

    }

}

//后序遍历二叉树:先遍历左子树，再遍历右子树,最后节点数据域

void PostOrderBiTree(Btree* root)

{

    Btree* pTreeNode = NULL;

    pTreeNode = root;

    if(pTreeNode == NULL)

    {

        return ;

    }

    else

    {

        PostOrderBiTree(pTreeNode->pLeft);

        PostOrderBiTree(pTreeNode->pRight);

        cout << pTreeNode->Data << " ";

    }

}

//添加节点

void AddTreeNode(Btree *root, ElemType data)

{

    Btree* pParent = NULL;

    Btree* pNode = new Btree;

    pNode->Data = data;

    pNode->pLeft = NULL;

    pNode->pRight= NULL;

    //根节点为空，这创建根节点

    if (root == NULL)

    {

        root = pNode;

    }

    else

    {

        pParent = FindTreeNode(root, data);

        if (!pParent)

        {

           

        }

    }

}

//计算二叉树的深度

int BiTreeDepth(Btree *root)

{

    Btree *pTreeNode = root;

    int depleft = 0;

    int depright = 0;

    if (pTreeNode == NULL)

    {

        return 0;  // 节点为空， 深度为0

    }

    else

    {

        depleft = BiTreeDepth(pTreeNode->pLeft);

        depright = BiTreeDepth(pTreeNode->pRight);

        if (depleft > depright)

        {

            return ++depleft;

        }

        else

        {

            return ++depright;

        }

    }

}

in
9c8a
t _tmain(int argc, _TCHAR* argv[])

{

     ElemType data;

     Btree *pRoot = NULL;

     Btree* pTreeNode = NULL;

     //构造根节点

     cin>>data;

     pTreeNode = CreateBiTree(pRoot, data);

     pRoot = pTreeNode;

     //添加树节点

    

     //{7,4,2,3,15,36,6,45,55,20,1,14,56,57,58};

     while(1)

     {

         //cout<<"pleasd input node data:"<<endl;

         cin>>data;

         if (data == '#') //'#' ASSCII = 35

         {

            break;

         }

         pTreeNode = CreateBiTree(pRoot, data);

     }

    

     //先序遍历

     cout<<"PreOrderBiTree"<<endl;

     PreOrderBiTree(pRoot);

     cout<<endl;

     //中序遍历

     cout<<"InOrder Bitnary Tree:"<<endl;

     InOrderBiTree(pRoot);

     cout<<endl;

     //后序遍历

     cout<<"post order Bitnary tree:"<<endl;

     PostOrderBiTree(pRoot);

     cout<<endl;

     //二叉树节点个数

     int num = BiTreeCount( pRoot);

     cout<<"node num:"<<num<<endl;

     //二叉树叶子节点个数

     int leafnum = FindLeafNodeNum( pRoot);

     cout<<"leafnode num:"<<leafnum<<endl;

    //二叉树深度

    int depth = BiTreeDepth(pRoot);

    cout<<"depth :"<<depth<<endl;

#if 1

     //查找节点 

     cout << "input find data:"<<endl;

     cin >>data;

     pTreeNode = FindTreeNode(pRoot, data);

     if (pTreeNode != NULL)

     {

         cout<<pTreeNode->Data<<endl;

     }

     else

     {

        cout<<"can not find "<<data<<" in Binary Tree";

     }

#endif

     ClearBiTree(pRoot);

    return 0;

   

}