二叉树的实现

二叉树的实现（链式的实现）

#include <iostream>
#include <cstdio>
#include <string>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

struct BTreeNode
{
	int date = 0;
	BTreeNode *left;
	BTreeNode *right;
};

class BTree {
public:
	BTree() {

	}
	//传参数的时候要注意，二叉树的结点时一个指针，若要改变二叉树结点的值，需要二级指针
	void create(BTreeNode* &Node)// 创建二叉树
	{
		int date;
		cin >> date;
		if ( date )
		{
			Node = new BTreeNode;
			Node->date = date;
			create(Node->left);
			create(Node->right);
		}
		else {
			Node = NULL;
		}
		
    }
	//按层创建二叉树
	void levelBTreeNode(BTreeNode * & Node)  //改变内容用二级指针
	{
		queue <BTreeNode*> q;
		int date = 0;
		cin >> date;
		if (date)
		{
			Node = new BTreeNode;
			Node->date = date;
			q.push(Node);
		}
		else {
			Node = NULL;
			return;
		}
		while (!q.empty())
		{
			BTreeNode *node = q.front();
			q.pop();
			//输入左子树
			cin >> date;
			if (date)
			{
				node -> left = new BTreeNode;
				node->left->date = date;
				q.push(node -> left);
			}
			else {
				node->left = NULL;
			}
			//输入右子树
			cin >> date;
			if (date)
			{
				node->right = new BTreeNode;
				node->right->date = date;
				q.push(node->right);
			}
			else {
				node->right = NULL;
			}
		}
	}
	//清空二叉树
	void clear( BTreeNode* & Node )
	{
		BTreeNode *p = Node;
		if (p != NULL)
		{
			clear(p->left);
			clear(p->right);
			delete p;
		}

	}
	//前序遍历（根左右）
	void preorderTree(BTreeNode*  Node)
	{
		if (Node != NULL)
		{
			cout << Node->date << " ";
			preorderTree(Node->left);
			preorderTree(Node->right);
		}
	}
	//中序遍历（左根右）
	void inorderTree(BTreeNode*  Node)
	{
		if (Node != NULL)
		{
			inorderTree(Node->left);
			cout << Node->date << " ";
			inorderTree(Node->right);
		}
	}
	//后序遍历
	void postorderTree(BTreeNode* Node)
	{
		if (Node != NULL)

		{
			postorderTree(Node->left);
			postorderTree(Node->right);
			cout << Node->date << " ";
		}
	}
	//图层遍历
	void levelTree(BTreeNode* Node)
	{
		queue <BTreeNode*> que;
		que.push(Node)
		while(!que.empty())
		{
			BTreeNode* node = que.front();
			cout << node->date << " ";
			que.pop();
			if (node->left != NULL) que.push(node->left);
			if (node->right != NULL) que.push(node->right);
		}

	}
	//二叉树深度
	int lenthofTree(BTreeNode* Node)
	{
		if (Node != NULL)
		{
			return max(lenthofTree(Node->left), lenthofTree(Node->right)) + 1;
		}
		else {
			return 0;
		}
	}
	//树的结点个数
	int getNodeNum(BTreeNode * Node)
	{
		if (Node != NULL)
		{
			return 1 + getNodeNum(Node->left) + getNodeNum(Node->right);
		}
		else {
			return 0;
		}
	}
	//叶节点的返回个数
	int getLeafNum(BTreeNode * Node)
	{
		if (Node == NULL) return 0;
		else {
			if (Node->left == NULL && Node->right == NULL)
			{
				return 1;
			}
			else {
				return getLeafNum(Node->left) + getLeafNum(Node->right);
			}
		}
	}

};

int main ()
{
	BTree tree;
	BTreeNode * root;
	//tree.create(root);
	tree.levelBTreeNode(root);//利用图层遍历创造二叉树
	cout << "pre:";
	tree.preorderTree(root);
	cout << endl;
	cout << "in:";
	tree.inorderTree(root);;
	cout << endl;
	cout << "post:";
	tree.postorderTree(root);
	cout << endl;
	cout << "level:";
	tree.levelTree(root);
	cout << endl;
	cout << tree.lenthofTree(root) << tree.getNodeNum(root) << tree.getLeafNum(root) << endl;
	tree.clear(root);
   return 0; 
}