AVL树的实现

代码如下：

#include<iostream>

using namespace std;

struct treeNode {
	treeNode *parent, *left, *right;
	int content;
	treeNode() {
		parent = NULL;
		left = NULL;
		right = NULL;
	}
};

class tree {
private:
	treeNode* head;
	void destroy(treeNode* node) {
		if(node == NULL)
			return;
		destroy(node->left);
		destroy(node->right);
		delete node;
	}
	void preorder(treeNode* node) {
		if(node == NULL)
			return;
		cout << node->content << "  ";
		preorder(node->left);
		preorder(node->right);
	}
	void inorder(treeNode* node) {
		if(node == NULL)
			return;
		inorder(node->left);
		cout << node->content << "  ";
		inorder(node->right);
	}
	void slturn(treeNode* node) {
		treeNode* grand = node->parent->parent;
		char tag;
		if(node->parent == node->parent->parent->left)
			tag = 'l';
		else
			tag = 'r';
		node->parent->left = node->right;
		if(node->right != NULL)
			node->right->parent = node->parent;
		node->right = node->parent;
		node->parent = node->right->parent;
		node->right->parent = node;
		if(tag == 'l')
			grand->left = node;
		else
			grand->right = node;
	}
	void srturn(treeNode* node) {
		treeNode* grand = node->parent->parent;
		char tag;
		if(node->parent == node->parent->parent->left)
			tag = 'l';
		else
			tag = 'r';
		node->parent->right = node->left;
		if(node->left != NULL)
			node->left->parent = node->parent;
		node->left = node->parent;
		node->parent = node->left->parent;
		node->left->parent = node;
		if(tag == 'l')
			grand->left = node;
		else
			grand->right = node;
	}
	void dlturn(treeNode* node) {
		treeNode* grand = node->parent->parent->parent;
		char tag;
		if(node->parent->parent == node->parent->parent->parent->left)
			tag = 'l';
		else
			tag = 'r';
		node->parent->right = node->left;
		if(node->left != NULL)
			node->left->parent = node->parent;
		node->parent->parent->left = node->right;
		if(node->right != NULL)
			node->right->parent = node->parent->parent;
		node->left = node->parent;
		node->right = node->parent->parent;
		node->parent->parent = node;
		node->parent->parent->parent = node;
		node->parent = grand;
		if(tag == 'l')
			grand->left = node;
		else
			grand->right = node;
	}
	void drturn(treeNode* node) {
		treeNode* grand = node->parent->parent->parent;
		char tag;
		if(node->parent->parent == node->parent->parent->parent->left)
			tag = 'l';
		else
			tag = 'r';
		node->parent->left = node->right;
		if(node->right != NULL)
			node->right->parent = node->parent;
		node->parent->parent->right = node->left;
		if(node->left != NULL)
			node->left->parent = node->parent->parent;
		node->right = node->parent;
		node->left = node->parent->parent;
		node->parent->parent = node;
		node->parent->parent->parent = node;
		node->parent = grand;
		if(tag == 'l')
			grand->left = node;
		else
			grand->right = node;
	}
	int depth(treeNode* node) {
		if(node == NULL)
			return 0;
		return 1+((depth(node->left) > depth(node->right))? depth(node->left): depth(node->right));
	}
public:
	tree() {
		head = new treeNode;
		//tree starts from head->left;
	}
	~tree() {
		destroy(head);
	}
	bool insert(int a) {
		if(head->left == NULL) {
			head->left = new treeNode;
			head->left->parent = head;
			head->left->content = a;
			return true;
		}
		treeNode* curr = head->left;
		treeNode* newlyinserted = NULL;
		while(curr->content != a) {
			if(curr->content > a) {
				if(curr->left != NULL)
					curr = curr->left;
				else {
					curr->left = new treeNode;
					curr->left->parent = curr;
					curr->left->content = a;
					newlyinserted = curr->left;
					break;
				}
			}
			else {
				if(curr->right != NULL)
					curr = curr->right;
				else {
					curr->right = new treeNode;
					curr->right->parent = curr;
					curr->right->content = a;
					newlyinserted = curr->right;
					break;
				}
			}
		}
		if(newlyinserted == NULL)
			return false;
		curr = newlyinserted->parent;
		while(curr != NULL && curr != head) {
			if(depth(curr->left) - depth(curr->right) >= 2) {
				if(depth(curr->left->left) > depth(curr->left->right))
					slturn(curr->left);
				else
					dlturn(curr->left->right);
			}
			else if(depth(curr->left) - depth(curr->right) <= -2) {
				if(depth(curr->right->right) > depth(curr->right->left))
					srturn(curr->right);
				else
					drturn(curr->right->left);
			}
			curr = curr->parent;
		}
		return true;
	}
	bool has(int a) {
		if(head->left == NULL)
			return false;
		treeNode* curr = head->left;
		while(curr->content != a) {
			if(curr->content > a) {
				if(curr->left != NULL)
					curr = curr->left;
				else
					return false;
			}
			else {
				if(curr->right != NULL)
					curr = curr->right;
				else
					return false;
			}
		}
		return true;
	}
	treeNode* find(int a) {
		if(head->left == NULL)
			return NULL;
		treeNode* curr = head->left;
		while(curr->content != a) {
			if(curr->content > a) {
				if(curr->left != NULL)
					curr = curr->left;
				else
					return NULL;
			}
			else {
				if(curr->right != NULL)
					curr = curr->right;
				else
					return NULL;
			}
		}
		return curr;
	}
	void print() {
		cout << "preorder: " << endl;
		preorder(head->left);
		cout << endl;
		cout << "inorder: " << endl;
		inorder(head->left);
		cout << endl;
	}
};

int main() {
	tree test;
	for(int i = 0; i < 9; i++) {
		cout << test.insert(i+1) << "  ";
	}
	cout << endl;
	for(int i = 1; i <= 9; i++) {
		cout << test.has(i) << "  ";
	}
	cout << endl;
	test.print();
	return 0;
}