Node.h
#pragma once
class Node
{
public:
int index;
int data;
Node *pLChild;
Node *pRChild;
Node *pParent;
Node();
Node* SearchNode(int nodeIndex);
void DeleteNode();
void PreorderTraversal();
void InorderTraversal();
void PostoerderTraversal();
};
查找结点,先看这个节点是否等于目标节点,然后递归看左右
删除,先递归删除左右子数,然后修改Parent的后继指向,最后在自杀
遍历就是,递归的三种遍历方式
Node.cpp
#include "Node.h"
#include<iostream>
Node::Node()
{
index = 0;
data = 0;
pLChild = NULL;
pRChild = NULL;
pParent = NULL;
}
Node* Node::SearchNode(int nodeIndex)
{
if (this->index == nodeIndex)
{
return this;
}
Node *temp = NULL;
if (this->pLChild != NULL)
{
if (this->pLChild->index == nodeIndex)
{
return this->pLChild;
}
else
{
temp = pLChild->SearchNode(nodeIndex);
if (temp != NULL)
return temp;
}
}
if (this->pRChild != NULL)
{
if (this->pRChild->index == nodeIndex)
{
return this->pRChild;
}
else
{
temp = this->pRChild->SearchNode(nodeIndex);
if (temp != NULL)
return temp;
}
}
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()
{
std::cout << this->index << " " << this->data << std::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();
}
std::cout << this->index << " " << this->data << std::endl;
if (this->pRChild != NULL)
{
this->pRChild->InorderTraversal();
}
}
void Node::PostoerderTraversal()
{
if (this->pLChild != NULL)
{
this->pLChild->PostoerderTraversal();
}
if (this->pRChild != NULL)
{
this->pRChild->PostoerderTraversal();
}
std::cout << this->index << " " << this->data << std::endl;
}
Tree.h
放一个根节点,以及前面的所以操作
#pragma once
#include"Node.h"
class Tree
{
private:
Node * m_pRoot;
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 PostoerderTraversal();
};
构造函数构造一个根,析构删除根节点
Tree.cpp
#include "Tree.h"
#include<cstdio>
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 == NULL)
return false;
Node *node = new Node();
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 == 0)
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::PostoerderTraversal()
{
m_pRoot->PostoerderTraversal();
}
最后是一个测试函数
#include<iostream>
#include "Tree.h"
#include "Node.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);
//tree->PreorderTraversal();
//tree->InorderTraversal();
//tree->PostoerderTraversal();
//tree->DeleteNode(6, NULL);
tree->DeleteNode(2, NULL);
tree->PreorderTraversal();
return 0;
}