链式二叉树C++（附带可执行源码）

     不同于线性表的一对一（一个节点只有一个直接前驱和一个直接后继），树是一对多的一种数据结构。（一个节点对应多个直接后继）。由于n叉树在实现过程中其分叉数目不定，而n叉树的问题大多可以化解成二叉树来理解，所以二叉树是重点研究对象。

链式二叉树是二叉树的一种存储形式，它的操作更加简单灵活，便于对于二叉树中的节点进行增删。

链式二叉树类

在链式二叉树构建类时，将节点类和树类分开定义

节点类及其构造函数析构函数

using namespace std;
template<typename T>
class TreeNode
{
public:
	T val;
	TreeNode<T>* left;
	TreeNode<T>* right;
public:
	TreeNode(T value);
	~TreeNode();
	
};

template<typename T>
inline TreeNode<T>::TreeNode(T value)
{
	val = value;
	left = nullptr;
	right = nullptr;
}

template<typename T>
inline TreeNode<T>::~TreeNode()
{
	delete right;
	delete left;
	left = nullptr;
	right = nullptr;
}

 树类

template<typename T>
class BinaryTree
{
private:
	TreeNode<T>* root;//创建节点类
public:
	BinaryTree();//构造函数
	~BinaryTree();//析构函数
	void insert(T value);//搜索二叉树插入函数
	TreeNode<T>* insertNode(TreeNode<T>* Node, T value);
	void leftTraversal();//中序遍历
	void leftTraversal(TreeNode<T>* node);
	void rightTraversal();//后序遍历
	void rightTraversal(TreeNode<T>*node);
	void midTraversal();//前序遍历
	void midTraversal(TreeNode<T>* node);
	int getDepth();//等到深度
	int getDepth(TreeNode<T>* node);
	int getleafCount();//叶子节点数
	int getleafCount(TreeNode<T>* node);
	void printsamelevel(int level);//各层的数据
	void printsamelevel(TreeNode<T>* node,int level);
	void destory(TreeNode<T>* node);//销毁树
	T getMaxvalue();//等到最大的数据
	T getMaxvalue(TreeNode<T>* node);
	T getParentNode(T value);
	TreeNode<T>* getParentNode(TreeNode<T>* node, T value);
};

构造及析构函数

template<typename T>
inline BinaryTree<T>::BinaryTree()//构造函数
{
	root = nullptr;//将根节点赋值为空
}

template<typename T>
inline BinaryTree<T>::~BinaryTree()
{
	destory(root);//递归将二叉树销毁
}

 增加节点

template<typename T>
inline TreeNode<T>* BinaryTree<T>::insertNode(TreeNode<T>* Node, T value)
{
	
	if (Node == nullptr)//当头节点都没有的时候，说明没有这个树
	{
		return new TreeNode<T>(value);//将这个节点进行赋值
	}
	else
	{
		bool isleft;
		cout << "向左[1]  向右[0]" << endl;
		cin >> isleft;
		if (isleft)//插入到左子树
		{
			Node->left = insertNode(Node->left, value);//向左递归
		}
		else
		{
			Node->right = insertNode(Node->right, value);//插入到右子树
		}
	}
	return Node;
}

 中序遍历（LDR）

template<typename T>
inline void BinaryTree<T>::leftTraversal()
{
	leftTraversal(root);
}

template<typename T>//中序遍历
inline void BinaryTree<T>::leftTraversal(TreeNode<T>* node)
{
	if (node != nullptr)
	{
		leftTraversal(node->left);
		cout << node->val << " ";
		leftTraversal(node->right);
	}
}

后序遍历

template<typename T>
inline void BinaryTree<T>::rightTraversal()
{
	rightTraversal(root);
}

template<typename T>//后序遍历
inline void BinaryTree<T>::rightTraversal(TreeNode<T>* node)
{
	if (node != nullptr)
	{
		rightTraversal(node->left);
		rightTraversal(node->right);
		cout << node->val << " ";
	}
}

先序遍历

template<typename T>
inline void BinaryTree<T>::midTraversal()
{
	midTraversal(root);
}

template<typename T>//先序遍历
inline void BinaryTree<T>::midTraversal(TreeNode<T>* node)
{
	if (node != NULL)
	{
		cout << node->val << " ";
		midTraversal(node->left); 
		midTraversal(node->right);
	}
}

 获取深度

template<typename T>
inline int BinaryTree<T>::getDepth()
{
	return getDepth(root);
}

template<typename T>
inline int BinaryTree<T>::getDepth(TreeNode<T>* node)
{
	if (node == nullptr)
	{
		return 0;
	}
	int leftDepth = getDepth(node->left);
	int rightDepth = getDepth(node->right);
	return max(leftDepth, rightDepth) + 1;
}

获取叶子节点

template<typename T>
inline int BinaryTree<T>::getleafCount()
{
	return getleafCount(root);
}

template<typename T>
inline int BinaryTree<T>::getleafCount(TreeNode<T>* node)
{
	if (node == nullptr)
	{
		return 0;
	}
	if (node->left == nullptr && node->right == nullptr)
	{
		return 1;
	}
	return getleafCount(node->left) + getleafCount(node->right);
}

获取同层节点

template<typename T>
inline void BinaryTree<T>::printsamelevel(int level)
{
	printsamelevel(root, level);
}

template<typename T>
inline void BinaryTree<T>::printsamelevel(TreeNode<T>* node, int level)
{
	if (node == nullptr)
	{
		return;
	}
	if (level == 1)
	{
		cout << node->val << " ";
	}
	else if (level > 1)
	{
		printsamelevel(node->left, level - 1);
		printsamelevel(node->right, level - 1);
	}
}

 获取节点最大值

 

template<typename T>
inline T BinaryTree<T>::getMaxvalue(TreeNode<T>* node)
{
	if (node == nullptr)
	{
		return 0;
	}
	int maxValue = node->val;
	int leftmax = getMaxvalue(node->left);
	int rightmax = getMaxvalue(node->right);
	if (leftmax > maxValue)
	{
		maxValue = leftmax;
	}
	if (rightmax > maxValue)
	{
		maxValue = rightmax;
	}
	return maxValue;
}

获取双亲节点

template<typename T>
inline TreeNode<T>* BinaryTree<T>::getParentNode(TreeNode<T>* node, T value)
{
	if (node == nullptr || node->val == value)
	{
		return nullptr;
	}
	else if ((node->left != nullptr && node->left->val == value) || (node->right != nullptr && node->right->val == value))
	{
		return node;
	}
	else
	{
		TreeNode<T>* parent = getParentNode(node->left, value);
		if (parent == nullptr)
		{
			parent = getParentNode(node->right, value);
		}
		return parent;
	}
}

主函数

#include"BInaryTree.h"
#include"Leader.h"
void menu()
{
	cout << "\t\t\t\t\t" << "[*************************************************]" << endl;
	cout << "\t\t\t\t\t" << "[*****************链式二叉树**********************]" << endl;
	cout << "\t\t\t\t\t" << "[*************************************************]" << endl;
	cout << "\t\t\t\t\t" << "[*****************1.插入数据**********************]" << endl;
	cout << "\t\t\t\t\t" << "[*****************2.中序遍历**********************]" << endl;
	cout << "\t\t\t\t\t" << "[*****************3.后序遍历**********************]" << endl;
	cout << "\t\t\t\t\t" << "[*****************4.先序遍历**********************]" << endl;
	cout << "\t\t\t\t\t" << "[*****************5.获取深度**********************]" << endl;
	cout << "\t\t\t\t\t" << "[*****************6.获取叶子节点数****************]" << endl;
	cout << "\t\t\t\t\t" << "[*****************7.获取同层节点******************]" << endl;
	cout << "\t\t\t\t\t" << "[*****************8.获取节点最大值****************]" << endl;
	cout << "\t\t\t\t\t" << "[*****************9.获取孩子双亲******************]" << endl;
	cout << "\t\t\t\t\t" << "[*************************************************]" << endl;
}



int main()
{
	BinaryTree<int>Tree;
	while (1)
	{
		menu();
		int x;
		cout << "请输入你的选择" << endl;
		cin >> x;
		switch (x)
		{
		case 1:
		{
			int data;
			cout << "请输入你的数据" << endl;
			cin >> data;
			Tree.insert(data);
		}break;
		case 2:
		{
			Tree.leftTraversal();
		}break;
		case 3:
		{
			Tree.rightTraversal();
		}break;
		case 4:
		{
			Tree.midTraversal();
		}break;
		case 5:
		{
			cout << "二叉树深度：" << Tree.getDepth() << endl;
		}break;
		case 6:
		{
			cout << "二叉树叶子节点个数：" << Tree.getleafCount() << endl;
		}break;
		case 7:
		{
			int level;
			cout << "你要查询哪一层？" << endl;
			cin >> level;
			Tree.printsamelevel(level);
		}break;
		case 8:
		{
			cout << "所有节点最大值：" << Tree.getMaxvalue() << endl;
		}break;
		case 9:
		{
			int val;
			cout << "请输入你要查找的值" << endl;
			cin >> val;
			cout << "改节点的双亲：" << Tree.getParentNode(val) << endl;
		}
		}
		system("pause");
		system("cls");
	}
}