二叉搜索树

二叉搜索树是一种结合了折半搜索策略的链接结构。树中的每一个节点都包含一个项目和两个指向其他节点（称为子节点，child node）的指针。这种构思是每一个节点都有两个子节点，左节点和右节点。其顺序按如此排列：在左节点中的项目是父节点中项目的前序列，而在右节点中的项目是父节点中项目后序项。这种关系存在于每一个有子节点的节点中。而且，所有能循其祖先回溯到左节点的项目都是该左节点的父节点项目的前序列，所有以右节点为祖先的父节点项目都是该右节点的父节点项目的后序列。

如果二叉树是满的，那么每一层的节点数都两倍于其上层的节点数。

实现代码：

//Tree.h

#include <iostream>
class Tree
{
public:
    Tree(int size, int *pRoot);                              //创建树
    ~Tree();                                                 //销毁树
    int *SearchNode(int nodeIndex);                          //根据索引寻找节点
    bool AddNode(int nodeIndex, int direction, int *pNode);  //添加节点
    bool DeleteNode(int nodeIndex, int *pNode);              //删除节点
    void TreeTraverse();                                     //遍历节点

private:
    int *m_pTree;
    int m_iSize;
};

//Tree.cpp

#include "Tree.h"

Tree::Tree(int size, int *pRoot)
{
    m_iSize = size;
    m_pTree = new int[size];
    for (int i = 0; i < size; i++)
    {
        m_pTree[i] = 0;
    }
    m_pTree[0] = *pRoot;  //创建根节点
}

Tree::~Tree()
{
    delete[] m_pTree;   //销毁节点
    m_pTree = NULL;
}

int *Tree::SearchNode(int nodeIndex)
{
    //如果节点不在范围内
    if (nodeIndex < 0 || nodeIndex >= m_iSize)
    {
        return NULL;
    }
    //如果节点等于0
    if (m_pTree[nodeIndex] == 0)
    {
        return NULL;
    }
    //返回对应的节点
    return &m_pTree[nodeIndex];
}

bool Tree::AddNode(int nodeIndex, int direction, int *pNode)
{
    if (nodeIndex < 0 || nodeIndex >= m_iSize)
    {
        return false;
    }
    if (m_pTree[nodeIndex] == 0)
    {
        return false;
    }
    //往左节点插入
    if (direction == 0)
    {
        //插入的节点位置大于树长度
        if (nodeIndex * 2 + 1 >= m_iSize)
        {
            return false;
        }
        //如果当前节点不为空
        if (m_pTree[nodeIndex * 2 + 1] != 0)
        {
            return false;
        }
        //插入节点
        m_pTree[nodeIndex * 2 + 1] = *pNode;
    }
    //往右节点插入
    if (direction == 1)
    {
        if (nodeIndex * 2 + 2 >= m_iSize)
        {
            return false;
        }
        if (m_pTree[nodeIndex * 2 + 2] != 0)
        {
            return false;
        }
        //插入节点
        m_pTree[nodeIndex * 2 + 2] = *pNode;
    }
    return true;
}

bool Tree::DeleteNode(int nodeIndex, int *pNode)
{
    if (nodeIndex < 0 || nodeIndex >= m_iSize)
    {
        return false;
    }
    //当前节点为空
    if (m_pTree[nodeIndex] == 0)
    {
        return false;
    }

    //删除节点赋给pNode，以便查看删除的节点
    *pNode = m_pTree[nodeIndex];
    m_pTree[nodeIndex] = 0;
    return true;
}

void Tree::TreeTraverse()
{
    //遍历树
    for (int i = 0; i < m_iSize; i++)
    {
        std::cout << m_pTree[i] << " ";
    }
}

//main.cpp

#include <iostream>
#include "Tree.h"
using namespace std;

int main()
{
    int root = 3;
    Tree *pTree = new Tree(10, &root);
    int node1 = 5;
    int node2 = 8;
    pTree->AddNode(0, 0, &node1);
    pTree->AddNode(0, 1, &node2);

    int node3 = 2;
    int node4 = 6;
    pTree->AddNode(1, 0, &node3);
    pTree->AddNode(1, 1, &node4);

    int node5 = 9;
    int node6 = 7;
    pTree->AddNode(2, 0, &node5);
    pTree->AddNode(2, 1, &node6);

    int node = 0;
    pTree->DeleteNode(6, &node);
    cout << "node = " << node << endl;

    pTree->TreeTraverse();

    int *p = pTree->SearchNode(2);
    cout << endl <<  "node =" << *p << endl;

    delete pTree;
    return 0;
}

Input：

node = 7
3 5 8 2 6 9 0 0 0 0
node =8​