树

简介

链表、对战和队列都是线性数据结构，树是非线性、二维数据结构。树的结点包含两个或更多个链接.
二叉树，所以节点都包含两个链接（链接中没有或有一个或有两个是nullptr.
二叉查找树，左子树值小于父节点，右子树值大于父节点。同一组二叉查找树的形状可以不同。

1. 中序遍历，对给定每个点先处理左子树，再处理该节点，最后处理右子树，是一种升序遍历
2. 前序遍历，先处理给定点，再处理左子树，最后处理右子树。
3. 后续遍历，先处理左子树，再处理右子树，最后处理给定点。

二叉查找树实现

类模板TreeNode

//****************TreeNode类模板*****************

#ifndef TREENODE_H
#define TREENODE_H

template <typename NODETYPE>class Tree;
template <typename NODETYPE>
class TreeNode
{
    friend class Tree<NODETYPE>;
public:
    TreeNode(NODETYPE &info):leftPtr(nullptr),data(info),rightPtr(nullptr)
    {

    }
    
    NODETYPE getData() const
    {
        return data;
    }
private:
    TreeNode<NODETYPE> *leftPtr;
    NODETYPE data;
    TreeNode<NODETYPE> *rightPtr;
};

#endif

类模板Tree

#ifndef TREE_H
#define TREE_H
#include <iostream>
#include "TreeNode.h"
template<typename NODETYPE>
class Tree
{
public:
    Tree():rootPtr(nullptr)
    {
//empty body
    }

    void insertNode(const NODETYPE& value) 
    {
        insertNodeHelper(&rootPtr, value);   //  将rootPtr指针的地址作为参数
    }
    void preOderTraversal() const
    {
        preOrderHelper(rootPtr);              // 工具函数
    }
    void inOderTraversal() const
    {
        inOrderHelper(rootPtr);
    }
    void postOderTraversal() const
    {
        postOrderHelper(rootPtr);
    }
	TreeNode<NODETYPE>* binaryTreeSearch(const NODETYPE& value) const 
    {
        return searcher(rootPtr, value);
    }

private:
    TreeNode<NODETYPE> *rootPtr;
    //***************插入节点
    void insertNodeHelper(TreeNode<NODETYPE> **ptr,NODETYPE& value)   //
    {
        if(*ptr==nullptr)
            *ptr = new TreeNode <NODETYPE> (value);      //修改rootPtr
        else
        {
            if(value < (*ptr)->data )
                insertNode(&((*ptr)->leftPtr), value);   //递归
            else
            {
                if(value > (*ptr)->data )
                    insertNode(&((*ptr)->rightPtr), value);
                else
                    std::cout << value << "dup" << endl;  //忽略，报告重复
            }
        }
    }

    //****************前序遍历
    void PreOrderHelper(TreeNode<NODETYPE>* ptr) const
    {
        if(ptr!=nullptr)
        {
            std::cout << ptr->data << ' ';       //处理当前点
            PreOrderHelper(ptr->leftPtr);        //处理左子树
            PreOrderHelper(ptr->rightPtr);       //处理右子树
        }
    }
    //****************中序遍历
    void inOrderHelper(TreeNode<NODETYPE>* ptr) const
    {
        if (ptr!=nullptr)
        {
            inOrderHelper(ptr->leftPtr);         //处理左子树
            std::cout << ptr->data << ' ';       //处理当前点
            inOrderHelper(ptr->rightPtr);        //处理右子树
        }
    }
    //****************后续遍历
    void postOrderHelper(TreeNode<NODETYPE>* ptr) const
    {
        if (ptr!=nullptr)
        {
            postOrderHelper(ptr->leftPtr);       //处理左子树
            postOrderHelper(ptr->rightPtr);      //处理右子树
            std::cout << ptr->data << ' ';       //处理当前点
        }
    }
    //***************二叉树查找函数，前序遍历搜索
    TreeNode<NODETYPE> * searcher(TreeNode<NODETYPE> *ptr, value)
    {
        if (ptr!=nullptr)
        {
            if(ptr->data == value)
                return ptr;
            else
            {
                searcher(ptr->leftPtr,value);
                searcher(ptr->rightPtr, value);
                return nullptr;
            }       
        }
    }
};
#endif