C++数组实现最简单的二叉树

• 二叉树可以用数组方式去实现，也可以用链表方式去实现。链表方式有点难，这里先用数组方式实现最简单的二叉树的-建立树，删除节点，增加节点，遍历节点，查找节点等。
• 头文件中构建类的代码，在CPP文件中实现，体现了C++的封装性特点。

#ifndef Tree_h_
#define Tree_h_

class Tree
{
public:
    Tree(int size,int* PRoot);//构造函数来初始化树的空间
    ~Tree();//析构函数
    int*  SearchNode(int nodeIndex);//通过数组的索引来查找树上的节点
    bool AddNode(int nodeIndex, int direction, int* pNode);//direction赋值0或者1来实现插入的是左孩子还是右孩子。第几个节点用nodeIndex来表示
                                                                                         //节点上的值用p_Tree[nodeIndex]来表示，而pNode表示的是要插入树的值。
    bool DeleteNode(int nodeIndex,int* pNode);//pNode用来存储从树上删除下来的值。
    void TreeTravel();//遍历节点只需要通过遍历数组就可以就可以
private:
    int* m_pTree;//一个整型指针，在构造函数中，堆上实例化对象后可以当数组用。
    int m_iSize;
};

#endif

• 下面是CPP文件代码

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

Tree::Tree(int size, int* PRoot)
{
    m_iSize = size;
    //m_pTree = new int(m_iSize);
    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;
    }
    if (m_pTree[nodeIndex] == 0)
    {
        return NULL;
    }
    else
    {
        return &m_pTree[nodeIndex];
    }
}
/*
函数解释：难点就是这个增加节点，这里有3个入口参数，第一个代表父亲节点的索引号，也就是第几个数节点，
                第二个参数决定了插入的是父亲的左孩子还是右孩子，第3个是传入的一个地址，为整型数据（可以不是整型，是自己构造的类型数据）
                ，将&pNode上的数据赋值给数组元素，这个数组元素就是树用来存放数据的。
*/
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[2 * nodeIndex + 1] = *pNode;
    }
    if (direction == 1)//插入右孩子
    {
        if(nodeIndex * 2 + 2>= m_iSize)
        {
            return false;
        }
        if (m_pTree[nodeIndex * 2 + 2] != 0)
        {
            return false;
        }
        m_pTree[2 * nodeIndex + 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 = m_pTree[nodeIndex];//这个是删除节点，与增加节点相反。
    m_pTree[nodeIndex] = 0;
    return true;
}

void Tree::TreeTravel() //就是遍历数组，比遍历链表简单
{
    for (int i = 0; i < m_iSize; i++)
    {
        cout << m_pTree[i] << " ";
    }
    cout << endl;
}

最后是这个demo的主函数代码

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

int main()
{
    int root = 1;
    Tree* pTree = new Tree(10,&root);//这里加一个root参数原因是要传入一个最开始的根节点。
    int node1 = 1;
    int node2 = 2;
    pTree->AddNode(0, 0, &node1);
     pTree->AddNode(0, 1, &node2);

    int node3 = 3;
    int node4 = 4;
    pTree->AddNode(1, 0, &node3);
    pTree->AddNode(1, 1, &node4);

    int node5= 5;
    int node6 = 6;
    pTree->AddNode(2, 0, &node5);
    pTree->AddNode(2, 1, &node6);
    pTree->TreeTravel();

    int node = 0;
    pTree->DeleteNode(3, &node);
    pTree->TreeTravel();
    int* p = pTree->SearchNode(2);

    cout << *p << endl;
    pTree->TreeTravel();
    delete pTree;
    system("pause");
    return 0;
}

后面再来分享链表的学习。共勉@！！！！