二叉树的总结

//BTNode.h

#ifndef BTNODE_H
#define BTNODE_H
#include <cstdio>



typedef int datatype;

typedef struct BTNode{           //定义节点
	datatype data;
	BTNode* left;
	BTNode* right;
	BTNode(datatype dataPara)
		:data(dataPara),left(NULL),right(NULL){};
}*nodePtr;
#endif

//BT.h

#pragma once         
#ifndef BT_H
#define BT_H
#include "BTNode.h"
#include <iostream>
#include <queue>
using namespace std;
class BT
{
public:
	BT():rootPtr(new BTNode(1)){ };
	~BT();
	//void addNode(datatype dataPara); //build a BT
	//void delNode(datatype dataPara);
	void preBuild(nodePtr &root); //C++在子函数中对指针赋值时，形参一定要传递指针的引用
	void allBuild();//层次建立一个二叉树，这是华为机试的一道题，挺有意思的
	void initBT();//真正建立二叉树的函数，可以调用上面的preBuild或allBuild
	void reverse();//真正遍历二叉树的函数，可以调用以下四种遍历方式
	void preRevHelp(nodePtr &node);
	void inRevHelp(nodePtr &node);
	void allRevHelp(nodePtr &node);//层次遍历
	void postRevHelp(nodePtr &node);
	int depthHelp(nodePtr &node);//求节点深度，形参是节点的指针
	void  queryDepthHelp(datatype val, nodePtr &node);//这也是一个递归函数，调用了上面的depthHelp，形参有一个node是为了方便递归
	int queryDepth(datatype val);//输入一个节点所保存的数据，查找并求深度，实际上调用了上面的Help，查找的过程用了遍历，找到了val则调用depthHelp
	nodePtr rootPtr;//一个空节点，rootPtr->left才是二叉树真正的根节点
private:
	int depth;//用来保存查到的深度值
	
};
#endif

//BT.cpp

#include "BT.h"





BT::~BT()
{
}



void BT::preBuild(nodePtr &node)//前序遍历
{
	datatype data;
	cin >> data;
	if (data == -1)
		node = NULL;
	else
	{
		node = new BTNode(data);
		preBuild(node->left);
		preBuild(node->right);
	}
}

void BT::initBT()
{
	//preBuild(rootPtr->left);
	allBuild(); 
}

void BT::preRevHelp(nodePtr &node)
{
	if (node != NULL)
	{
		cout << node->data;
		preRevHelp(node->left);
		preRevHelp(node->right);
	}
}

void BT::reverse()
{
	cout << "这是先序遍历的结果：" << endl;
	preRevHelp(rootPtr->left);
	cout << endl<< "这是中序遍历的结果：" << endl;
	inRevHelp(rootPtr->left);
	cout << endl<< "这是后序遍历的结果：" << endl;
	postRevHelp(rootPtr->left);
	cout << endl<<"这是层次遍历的结果：" << endl;
	allRevHelp(rootPtr->left);
}


void BT::inRevHelp(nodePtr &node)
{
	if (node != NULL)
	{
		inRevHelp(node->left);
		cout << node->data <<" ";
		inRevHelp(node->right);
	}
}

void BT::postRevHelp(nodePtr &node)
{
	if (node != NULL)
	{
		postRevHelp(node->left);
		postRevHelp(node->right);
		cout << node->data << " ";
	}
}

void BT::allRevHelp(nodePtr &node)
{
	vector <nodePtr> curr;
	vector <nodePtr> temp;
	curr.push_back(node);
	while (!curr.empty())
	{
		for (vector <nodePtr>::const_iterator i = curr.begin(); i != curr.end(); ++i)
		{
			cout << (*i)->data << " ";
			if ((*i)->left)temp.push_back((*i)->left);
			if ((*i)->right)temp.push_back((*i)->right);
		}
		curr = temp;
		temp.clear();
	}
}

int BT::depthHelp(nodePtr &node)
{
	if (node == NULL)
		return 0;
	else
		return max(depthHelp(node->left), depthHelp(node->right)) + 1;
}

void BT::allBuild() //层次建树就不要用递归了
{
	vector <nodePtr> pre;
	vector <nodePtr> curr;
	//nodePtr child;//这个指针用来更新树中的父子节点关系
	int preIndex = 0;
	int currIndex = 0;
	int currLayer = 1; //这里配合题目需要，把顶层的序号设为1
	int value;
	int layer;
	pre.push_back(rootPtr); //先把最顶层的节点给推进来
	while (cin >> value >> layer)
	{
		nodePtr node = new BTNode(value);
		if (layer != currLayer)
		{
			currLayer = layer;
			pre = curr; //更新容器
			curr.clear();
			currIndex = preIndex = 0;			
		}
		curr.push_back(node);
		if (!currIndex % 2)
			pre[preIndex]->left = node;
		else
		{
			pre[preIndex]->right = node;
			++preIndex;
		}
		++currIndex;
	}
	cin.clear();
}

void BT::queryDepthHelp(datatype val, nodePtr &node)//这里模仿先序遍历去查找一个值
{
	if (node != NULL)
	{
		if (node->data == val) depth =  depthHelp(node);//找到了就调用depthHelp去找他的深度
		queryDepthHelp(val, node->left);
		queryDepthHelp(val, node->right);
	}//没找到就输出-1
}

int BT::queryDepth(datatype val)
{
	depth = -1;
	queryDepthHelp(val, rootPtr->left);
	return depth;
}

//Main.cpp

<pre class="cpp" name="code">#include "BT.h"
int main()
{
	BT A;
	A.initBT();
	//cout << A.rootPtr->data;
	A.reverse();
	cout << "节点3的深度为" << A.queryDepth(3) << endl;
	//system("pasue");
	return 0;
}

先贴上代码，有时间再详解。老规矩：先挖坑，有空更。