二叉树（链表表示）

Posted 2021-03-06 chengmf

Node.h

#pragma once

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

Node.cpp

#include "Node.h"
#include<iostream>
using namespace std;
Node::Node()
{
    index = 0;
    data = 0;
    pLChild = nullptr;
    pRChild = nullptr;
    pParent = nullptr;
}

Node* Node::SearchNode(int nodeindex)
{
    Node* temp = nullptr;
    if (this->index == nodeindex)return this;
    if (this->pLChild != nullptr)
    {
        if (this->pLChild->index == nodeindex)
        {
            return this->pLChild;
        }
        else
        {
            temp = this->pLChild->SearchNode(nodeindex);
            if (temp != nullptr)return temp;
        }
            
    }
    if (this->pRChild != nullptr)
    {
        if (this->pRChild->index == nodeindex)
        {
            return this->pRChild;
        }
        else
        {
            temp = this->pRChild->SearchNode(nodeindex);
            if (temp != nullptr)return temp;
        }
    }
    return nullptr;
}

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

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

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

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

Tree.h

#pragma once
#include"Node.h"

class Tree
{
public:
    Tree();
    ~Tree();
    Node* SearchNode(int indexnode);
    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.cpp

#include "Tree.h"

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

Tree::~Tree()
{
    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 == nullptr)return false;
    Node* node = new Node();
    if (node == nullptr)return false;
    node->index = pNode->index;
    node->data = pNode->data;
    node->pParent = temp;
    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 == nullptr)return false;

    if (pNode != nullptr)
    {
        pNode->index = temp->index;
        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();
}

源.cpp

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

/*
        (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);

    cout << "前序遍历结果为：" << endl;
    tree->PreorderTraversal();

    cout << "中序遍历结果为：" << endl;
    tree->InorderTraversal();

    cout << "后序遍历结果为：" << endl;
    tree->PostorderTraversal();

    tree->DeleteNode(2, nullptr);

    cout << "前序遍历结果为：" << endl;
    tree->PreorderTraversal();

    delete tree;
    tree = nullptr;
    return 0;
}