c++实现平衡二叉树（看着java写的c++）

 类的声明：

    首先是新手，目前还没有学到嵌套类和模板，所以写的有些欠缺，同时我习惯了java的编译器的代码风格，所以一些人看起来不是很舒服。

#pragma once
#include 
using namespace std;

class Node {
public:
	int data;
	int height;
	Node* lChild;
	Node* rChild;
	Node(int d = 0, int h = 0, Node* lC = NULL, Node* rC = NULL) {
		data = d;
		height = h;
		lChild = lC;
		rChild = rC;
	}
};

class AvlTree {
private:
	Node* root;
	//查看节点
	void visit(Node* node);
	Node* insert(int data, Node* t);
	Node* balance(Node* t);
	int height(Node* t);
	Node* rotateWithLeftChild(Node* desNode);
	Node* rotateWithRightChild(Node* desNode);
	Node* doubleWithLeftChild(Node* unbalanceNode);
	Node* doubleWithRightChild(Node* unbalanceNode);
	Node* findMax(Node* t);
	Node* findMin(Node* t);
	void print(Node* t, int h);
	//先序遍历(递归)
	void preTraverse(Node* node);
	//中序遍历(递归)
	void inTraverse(Node* node);
	//后序遍历(递归)
	void postTraverse(Node* node);
	Node* remove(int data, Node* t);
	void dostroy(Node* t);
public:
	AvlTree();
	~AvlTree();
	void insert(int data);
	int findMin();
	int findMax();
	void print();
	//先序遍历(递归)
	void preTraverse();
	//中序遍历(递归)
	void inTraverse();
	//后序遍历(递归)
	void postTraverse();
	void remove(int data);
};

类的定义：

#include 
#include 
#include "AvlTree.h"

using namespace std;

//private

void AvlTree::visit(Node* node) {
	cout << node->data << " ";
}
Node* AvlTree::insert(int data, Node* t) {
	if (t == NULL)
		return new Node(data);
	int compareResult = data - t->data;
	if (compareResult < 0) {
		t->lChild = insert(data, t->lChild);
	}
	else if (compareResult > 0) {
		t->rChild = insert(data, t->rChild);
	}
	return balance(t);
}
Node* AvlTree::balance(Node* t) {
	if (t == NULL)
		return t;
	if (height(t->lChild) - height(t->rChild) > 1) {
		if (height(t->lChild) >= height(t->rChild))
			t = rotateWithLeftChild(t);
		else
			t = doubleWithLeftChild(t);
	}
	else if (height(t->rChild) - height(t->lChild) > 1) {
		if (height(t->rChild) >= height(t->lChild))
			t = rotateWithRightChild(t);
		else
			t = doubleWithRightChild(t);
	}
	t->height = max(height(t->lChild), height(t->rChild)) + 1;
	return t;
}
int AvlTree::height(Node* t) {
	return t == NULL ? -1 : t->height;
}
Node* AvlTree::rotateWithLeftChild(Node* desNode) {
	Node* ascNode = desNode->lChild;
	desNode->lChild = ascNode->rChild;
	ascNode->rChild = desNode;
	desNode->height = max(height(desNode->lChild), height(desNode->rChild)) + 1;
	ascNode->height = max(height(ascNode->lChild), height(ascNode->rChild)) + 1;
	return ascNode;
}
Node* AvlTree::rotateWithRightChild(Node* desNode) {
	Node* ascNode = desNode->rChild;
	desNode->rChild = ascNode->lChild;
	ascNode->lChild = desNode;
	desNode->height = max(height(desNode->lChild), height(desNode->rChild)) + 1;
	ascNode->height = max(height(ascNode->lChild), height(ascNode->rChild)) + 1;
	return ascNode;
}
Node* AvlTree::doubleWithLeftChild(Node* unbalanceNode) {
	unbalanceNode->lChild = rotateWithRightChild(unbalanceNode->lChild);
	return rotateWithLeftChild(unbalanceNode);
}
Node* AvlTree::doubleWithRightChild(Node* unbalanceNode) {
	unbalanceNode->rChild = rotateWithLeftChild(unbalanceNode->rChild);
	return rotateWithRightChild(unbalanceNode);
}
Node* AvlTree::findMax(Node* t) {
	if (t == NULL)
		return NULL;
	else if (t->rChild == NULL)
		return t;
	return findMax(t->rChild);
}
Node* AvlTree::findMin(Node* t) {
	if (t == NULL)
		return NULL;
	else if (t->lChild == NULL)
		return t;
	return findMin(t->lChild);
}
void AvlTree::print(Node* t, int h) {
	if (t != NULL) {
		print(t->rChild, h + 1);
		for (int i = 0; i < h; i++) {
			cout << "     ";
		}
		cout << t->data << endl;
		print(t->lChild, h + 1);
	}
}
//查看节点
//先序遍历(递归)
void AvlTree::preTraverse(Node* node) {
	if (node == NULL)
		return;
	visit(node);
	preTraverse(node->lChild);
	preTraverse(node->rChild);
}
//中序遍历(递归)
void AvlTree::inTraverse(Node* node) {
	if (node == NULL)
		return;
	inTraverse(node->lChild);
	visit(node);
	inTraverse(node->rChild);
}
//后序遍历(递归)
void AvlTree::postTraverse(Node* node) {
	if (node == NULL)
		return;
	postTraverse(node->lChild);
	postTraverse(node->rChild);
	visit(node);
}
Node* AvlTree::remove(int data, Node* t) {
	if (t == NULL)
		return t;
	int compareResult = data - t->data;
	if (compareResult < 0)
		t->lChild = remove(data, t->lChild);
	else if (compareResult > 0)
		t->rChild = remove(data, t->rChild);
	else
		if (t->lChild != NULL && t->rChild != NULL) {
			t->data = findMin(t->rChild)->data;
			t->rChild = remove(t->data, t->rChild);
		}
		else {
			Node* temp = t;
			t = t->lChild != NULL ? t->lChild : t->rChild;
			delete temp;
		}
	return balance(t);
}
void AvlTree::dostroy(Node* t) {
	if (t == NULL)
		return;
	dostroy(t->lChild);
	dostroy(t->rChild);
	delete t;
	t = NULL;
}


//public

AvlTree::AvlTree() :root(NULL) {}
AvlTree::~AvlTree() {
	dostroy(root);
}
void AvlTree::print() {
	print(root, 0);
}
//插入
void AvlTree::insert(int data) {
	root = insert(data, root);
}
int AvlTree::findMax() {
	return findMax(root)->data;
}
int AvlTree::findMin() {
	return findMin(root)->data;
}
//先序遍历(递归)
void AvlTree::preTraverse() {
	preTraverse(root);
}
//中序遍历(递归)
void AvlTree::inTraverse() {
	inTraverse(root);
}
//后序遍历(递归)
void AvlTree::postTraverse() {
	postTraverse(root);
}
void AvlTree::remove(int data) {
	root = remove(data, root);
}

我是刚学c++没多久，java也一知半解，所以还请见谅。