数据结构-链表二叉树-【C++模板实现】

    此树根节点索引为0，不存储数据节点，从根节点开始向下的节点开始存储数据，也就是从节点1开始存储数据。

Node.h

#pragma once
#include<iostream>

using namespace std;

template<class T>
class Node
{
public:
	int index;
	T data;

	Node<T> * pLChild;
	Node<T> * pRChild;
	Node<T> * pParent;

	Node(int index = 0,T data = 0) 
	{
		this->index = index;
		this->data = data;
		pLChild = NULL;
		pRChild = NULL;
		pParent = NULL;
	}

	Node(const Node<T> & node)
	{
		index = node.index;
		data = node.data;
		pLChild = NULL;
		pRChild = NULL;
		pParent = NULL;
	}

	Node<T> * SearchNode(int nodeIndex)
	{
		if (index == nodeIndex)
			return this;

		Node * temp = NULL;
		if (pLChild != NULL)
		{
			temp = pLChild->SearchNode(nodeIndex);
			if (temp != NULL) return temp;
		}
		if (pRChild != NULL)
		{
			temp = pRChild->SearchNode(nodeIndex);
			if (temp != NULL) return temp;
		}

		return NULL;
	}

	void DeleteNode()
	{
		if (pLChild != NULL)
			pLChild->DeleteNode();

		if (pRChild != NULL)
			pRChild->DeleteNode();

		if (pParent != NULL)
		{
			if (pParent->pLChild == this)
				pParent->pLChild = NULL;
			if (pParent->pRChild == this)
				pParent->pRChild = NULL;
		}

		delete this;
	}

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

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

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

	~Node() {}

	friend ostream& operator<<(ostream &os, const Node<T> *node)
	{
		os << node->data;
		return os;
	}
};

Tree.h

#pragma once
#include"Node.h"
template<class T>
class Tree
{
public:
	Tree();//传递初始头数据节点的值与容量
	~Tree();
	Node<T> * SearchNode(int nodeIndex);
	bool AddNode(int nodeIndex, bool direction, const Node<T> & pNode);//direction = false 表示左孩子，true表示右孩子
	bool DeleteNode(int nodeIndex);
	void PreorderTraversal();
	void InorderTraversal();
	void PostorderTraversal();

private:
	Node<T> * m_pRoot;//以索引0开始为头节点

};

Tree.cpp

#include<iostream>
#include"Tree.h"

using namespace std;

template<class T>
Tree<T>::Tree()
{
	m_pRoot = new Node<T>();
}

template<class T>
Tree<T>::~Tree()
{
	DeleteNode(0);
}

template<class T>
Node<T> * Tree<T>::SearchNode(int nodeIndex)
{
	return m_pRoot->SearchNode(nodeIndex);
}

template<class T>
bool Tree<T>::AddNode(int nodeIndex, bool direction,const Node<T> & pNode)
{
	Node<T> * temp = SearchNode(nodeIndex);
	if (temp == NULL) return false;

	Node<T> * node = new Node<T>(pNode);
	node->pParent = temp;

	if (!direction)//挂载到左孩子
	{
		if (temp->pLChild != NULL)
			return false;

		temp->pLChild = node;
		return true;
	}

	if (direction)//挂载到右孩子
	{
		if (temp->pRChild != NULL)
			return false;

		temp->pRChild = node;
		return true;
	}

	return false;
}

template<class T>
bool Tree<T>::DeleteNode(int nodeIndex)
{
	Node<T> * temp = SearchNode(nodeIndex);
	if (temp == NULL)
		return false;

	temp->DeleteNode();
	return true;
}

template<class T>
void Tree<T>::PreorderTraversal()
{
	m_pRoot->PreorderTraversal();
}

template<class T>
void Tree<T>::InorderTraversal()
{
	m_pRoot->InorderTraversal();
}

template<class T>
void Tree<T>::PostorderTraversal()
{
	m_pRoot->PostorderTraversal();
}

main.cpp

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

/*建立如图所示树
		  (0)
	  5(1)		 8(2)
       2(3)   6(4)    9(5)   7(6)
*/

int main()
{
	Tree<int> * tree = new Tree<int>();

	Node<int> node1(1, 5);
	Node<int> node2(2, 8);
	Node<int> node3(3, 2);
	Node<int> node4(4, 6);
	Node<int> node5(5, 9);
	Node<int> node6(6, 7);

	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->DeleteNode(1);

	tree->PreorderTraversal();
	//tree->InorderTraversal();
	//tree->PostorderTraversal();
	delete tree;
	return 0;
}