树链表

#include<iostream>
using namespace std;

class Node
{
public:
    Node();
    Node *SearchNode(int nodeIndex);
    void DeleteNode();
    void PreorderTraversal();
    void InorderTraversal();
    void PostorderTraversal();
    int index;
    int data;
    Node *pLChild;
    Node *pRChild;
    Node *pParent;
};

Node::Node()
{
    index=0;
    data=0;
    pLChild=NULL;
    pRChild=NULL;
    pParent=NULL;
}

Node *Node::SearchNode(int nodeIndex)
{
    if(this->index==nodeIndex)
    {
        return this;
    }
    if(this->pLChild!=NULL)
    {
        if(this->pLChild->index==nodeIndex)
        {
            return this->pLChild;
        }
    }
    if(this->pRChild!=NULL)
    {
        if(this->pRChild->index==nodeIndex)
        {
            return this->pRChild;
        }
    }
    return NULL;
}

void Node::DeleteNode()
{
    if(this->pLChild!=NULL)
    {
        this->pLChild->DeleteNode();
    }
    if(this->pRChild!=NULL)
    {
        this->pRChild->DeleteNode();
    }
    if(this->pParent!=NULL)
    {
        if(this->pParent->pLChild==this)
        {
            this->pParent->pLChild=NULL;
        }
        if(this->pParent->pRChild==this)
        {
            this->pParent->pRChild=NULL;
        }
    }

    delete this;
}


void Node::PreorderTraversal()
{
    cout<<this->index<<' '<<this->data<<endl;
    if(this->pLChild!=NULL)
    {
        this->pLChild->PreorderTraversal();
    }
    if(this->pRChild!=NULL)
    {
        this->pRChild->PreorderTraversal();
    }
}

void Node::InorderTraversal()
{
    if(this->pLChild!=NULL)
    {
        this->pLChild->InorderTraversal();
    }
    cout<<this->index<<' '<<this->data<<endl;
    if(this->pRChild!=NULL)
    {
        this->pRChild->InorderTraversal();
    }
}

 void Node::PostorderTraversal()
{
     if(this->pLChild!=NULL)
    {
        this->pLChild->PostorderTraversal();
    }
    if(this->pRChild!=NULL)
    {
        this->pRChild->PostorderTraversal();
    }
    cout<<this->index<<' '<<this->data<<endl;
}

class Tree
{
public:
    Tree();                              //创建树
    ~Tree();                           //销毁树
    Node *SearchNode(int nodeIndex);                    //搜索结点
    bool AddNode(int nodeIndex,int direction,Node *pNode);              //添加结点
    bool DeleteNode(int nodeIndex, Node *pNode);                            //删除结点
    void PreorderTraversal();                                     //前序遍历
    void InorderTraversal();                                        //中序遍历
    void PostorderTraversal();                                    //后序遍历

private:
    Node *m_pRoot;
};

Tree::Tree()
{
    m_pRoot=new Node();
}

Tree::~Tree()
{
    DeleteNode(0,NULL);
    //m_pRoot->DeleteNode(); 另一种方法
}
Node *Tree::SearchNode(int nodeIndex)
{
    return m_pRoot->SearchNode(nodeIndex);
}

bool Tree::AddNode(int nodeIndex,int direction,Node *pNode)
{
    Node *temp=SearchNode(nodeIndex);
    if(temp==NULL)
    {
        return false;
    }

    Node*node=new Node();
    if(node==NULL)
    {
        return false;
    }
    node->index=pNode->index;
    node->data=pNode->data;

    if(direction==0)
    {
        temp->pLChild=node;
    }
    if(direction==1)
    {
        temp->pRChild=node;
    }

    return true;
}

bool Tree::DeleteNode(int nodeIndex, Node *pNode)
{
    Node *temp=SearchNode(nodeIndex);
    if(temp==NULL)
    {
        return false;
    }

    if(pNode!=NULL)
    {
        pNode->data=temp->data;
    }

    temp->DeleteNode();
    return true;
}

void Tree::PreorderTraversal()
{
    m_pRoot->PreorderTraversal();
}

void Tree::InorderTraversal()
{
    m_pRoot->InorderTraversal();
}

void Tree::PostorderTraversal()
{
    m_pRoot->PostorderTraversal();
}
/*
                             3(0)
                5(1)                   8(2)
        2(3)       6(4)    9(5)       7(6)
*/
int main()
{
    Node *node1=new Node();
    node1->index=1;
    node1->data=5;

    Node *node2=new Node();
    node2->index=2;
    node2->data=8;

    Node *node3=new Node();
    node3->index=3;
    node3->data=2;

    Node *node4=new Node();
    node4->index=4;
    node4->data=6;

    Node *node5=new Node();
    node5->index=5;
    node5->data=9;

    Node *node6=new Node();
    node6->index=6;
    node6->data=7;

    Tree *tree=new Tree();

    tree->AddNode(0,0,node1);
    tree->AddNode(0,1,node2);

    tree->AddNode(1,0,node3);
    tree->AddNode(1,1,node4);

    tree->AddNode(2,0,node5);
    tree->AddNode(2,1,node6);

    tree->PreorderTraversal();
    cout<<endl;
    tree->InorderTraversal();
    cout<<endl;
    tree->PostorderTraversal();
    delete tree;
    return 0;
}