普通二叉树C++实现

数据结构作业- -没啥好说的

-BinaryTree.h

#ifndef __BIANRY_TREE_H__
#define __BINARY_TREE_H__

#include <iostream>
#include <queue>

template <class T>
struct BinTreeNode {
	T data;
	BinTreeNode* left;
	BinTreeNode* right;

	BinTreeNode(T value = 0, BinTreeNode* lt = NULL, BinTreeNode* rt = NULL)
		:data(value), left(lt), right(rt) {}
};

template <class T>
class BinaryTree {
public:
	BinaryTree() :root(NULL) {}
	BinaryTree(T value) :refValue(value), root(NULL) {}
	~BinaryTree() { destroy(); }

	bool isEmpty()const { return NULL == root; }
	int height()const { return height(root); }
	int size()const { return size(root); }

	BinTreeNode<T>* getParent(BinTreeNode<T>* node)const { return getParent(root, node); }
	BinTreeNode<T>* getLeftChild(BinTreeNode<T>* node)const { return node->left; }
	BinTreeNode<T>* getRightChild(BinTreeNode<T>* node)const { return node->right; }
	BinTreeNode<T>* getRoot()const { return root; }

	BinTreeNode<T>* find(const T& x)const { return find(root, x); }
	void preOrder(void(*visit)(BinTreeNode<T>* node))const { preOrder(root, visit); }
	void inOrder(void(*visit)(BinTreeNode<T>* node))const { inOrder(root, visit); }
	void postOrder(void(*visit)(BinTreeNode<T>* node))const { postOrder(root, visit); }
	void levelOrder(void(*visit)(BinTreeNode<T>* node))const;

	void createBinTree(std::istream& in) { destroy(); createBinTree(in, root); }
	void destroy() { destroy(root); }

private:
	BinTreeNode<T>* root;
	T refValue;

	int height(BinTreeNode<T>* node)const;
	int size(BinTreeNode<T>* node)const;

	BinTreeNode<T>* createBinTree(std::istream& in, BinTreeNode<T>*& node);
	BinTreeNode<T>* getParent(BinTreeNode<T>* subTree, BinTreeNode<T>* node)const;
	BinTreeNode<T>* find(BinTreeNode<T>* node, const T& x)const;

	void preOrder(BinTreeNode<T>* subTree, void(*visit)(BinTreeNode<T>* node))const;
	void inOrder(BinTreeNode<T>* subTree, void(*visit)(BinTreeNode<T>* node))const;
	void postOrder(BinTreeNode<T>* subTree, void(*visit)(BinTreeNode<T>* node))const;

	void destroy(BinTreeNode<T>*& node);

};

// Internal method: height
template <class T>
int BinaryTree<T>::height(BinTreeNode<T>* node)const {
	if (NULL == node) return 0;
	int h1 = height(node->left);
	int h2 = height(node->right);
	return h1 > h2 ? h1 + 1 : h2 + 1;
}

// Internal method: size
template <class T>
int BinaryTree<T>::size(BinTreeNode<T>* node)const {
	if (NULL == node) return 0;
	return size(node->left) + size(node->right) + 1;
}

// Internal method: getParent
template <class T>
BinTreeNode<T>* BinaryTree<T>::getParent(BinTreeNode<T>* subTree, BinTreeNode<T>* node)const {
	if (NULL == subTree) return NULL;
	if (subTree->left == node || subTree->right == node) return subTree;
	BinTreeNode<T>* p;
	if (NULL != (p = getParent(subTree->left, node))) 
		return p;
	else 
		return getParent(subTree->right, node);
}

// Internal method: preOrder(DLR)
template <class T>
void BinaryTree<T>::preOrder(BinTreeNode<T>* subTree, void(*visit)(BinTreeNode<T>* node))const {
	if (NULL == subTree) return;
	visit(subTree);
	preOrder(subTree->left, visit);
	preOrder(subTree->right, visit);
}

// Internal method: inOrder(LDR)
template <class T>
void BinaryTree<T>::inOrder(BinTreeNode<T>* subTree, void(*visit)(BinTreeNode<T>* node))const {
	if (NULL == subTree) return;
	inOrder(subTree->left, visit);
	visit(subTree);
	inOrder(subTree->right, visit);
}

// Internal method: preOrder(LRD)
template <class T>
void BinaryTree<T>::postOrder(BinTreeNode<T>* subTree, void(*visit)(BinTreeNode<T>* node))const {
	if (NULL == subTree) return;
	postOrder(subTree->left, visit);
	postOrder(subTree->right, visit);
	visit(subTree);
}

// Internal method: createBinTree
template <class T>
BinTreeNode<T>* BinaryTree<T>::createBinTree(std::istream& in, BinTreeNode<T>*& node) {
	T val;
	in >> val;
	if (val == refValue) return NULL;
	//node = new BinTreeNode<T>(val, createBinTree(in, node->left), createBinTree(in, node->right));
	node = new BinTreeNode<T>(val);
	node->left = createBinTree(in, node->left);
	node->right = createBinTree(in, node->right);
	return node;
}

// Internal method: destroy
template <class T>
void BinaryTree<T>::destroy(BinTreeNode<T>*& node) {
	if (NULL == node) return;
	destroy(node->left);
	destroy(node->right);
	delete node;
}

// Internal method: find
template <class T>
BinTreeNode<T>* BinaryTree<T>::find(BinTreeNode<T>* node, const T& x)const {
	if (node == NULL) return NULL;
	if (node->data == x) return node;
	BinTreeNode<T>* t;
	if (NULL != (t = find(node->left, x))) return t;
	else return find(node->right, x);
}

// levelOrder
template <class T>
void BinaryTree<T>::levelOrder(void(*visit)(BinTreeNode<T>* node))const {
	std::queue<BinTreeNode<T>*> Queue;
	if (NULL == root) return;
	BinTreeNode<T>* t = root;
	Queue.push(t);
	while (!Queue.empty()) {
		t = Queue.front();
		visit(t);
		Queue.pop();
		if (NULL != t->left) Queue.push(t->left);
		if (NULL != t->right) Queue.push(t->right);
	}
}


#endif

测试用例-main.cpp

#include "BinaryTree.h"
using namespace std;

template <class T>
void vs(BinTreeNode<T>* node) {
	cout << node->data << " ";
}

template <class T>
void order(const BinaryTree<T>& bt) {
	cout << "前序输出：";
	bt.preOrder(&vs);
	cout << endl;
	cout << "中序输出：";
	bt.inOrder(&vs);
	cout << endl;
	cout << "后序输出：";
	bt.postOrder(&vs);
	cout << endl;
	cout << "层序输出：";
	bt.levelOrder(&vs);
	cout << endl;
}

int main()
{
	BinaryTree<char> bt('#');
	// 构造二叉树
	bt.createBinTree(cin);
	
	if (bt.isEmpty()) cout << "该树为空" << endl;
	else cout << "该树不为空" << endl;

	BinTreeNode<char>* root = bt.getRoot();
	cout << "根节点为：" << root->data << endl;
	// left child
	if (NULL == bt.getLeftChild(root))
		cout << "左儿子为空" << endl;
	else
		cout << "左儿子为" << bt.getLeftChild(root)->data << endl;
	// right child
	if (NULL == bt.getRightChild(root))
		cout << "右儿子为空" << endl;
	else
		cout << "右儿子为" << bt.getRightChild(root)->data << endl;
	// parent
	if (NULL == bt.getParent(root))
		cout << "父节点为空" << endl;
	else
		cout << "父节点为" << bt.getParent(root)->data << endl;

	cout << (NULL != bt.find('A') ? "A为二叉树里面的节点" : "A不是二叉树里面的节点") << endl;
	cout << (NULL != bt.find('T') ? "T为二叉树里面的节点" : "T不是二叉树里面的节点") << endl;

	cout << "高度为：" << bt.height() << endl;
	cout << "节点数为：" << bt.size() << endl;

	order(bt);

	return 0;
}