笔记：构造AVL

#include<stdlib.h>
#include <stack>
#include <algorithm>
#include <iostream>
#include <map>
using namespace std;

struct AVLNode {
	int e;
	int bf = 0;  //平衡因子
	int h = -1;   //树深
	AVLNode* LChild, * RChild;
};
struct  AVLTree {
	int n;
	AVLNode* root;
};
void createAVL(AVLTree* T, int* arr, int len) {
	T->n = len;
	map<string, int> typemap;
	typemap.insert(pair<string, int>("LL", 1));
	typemap.insert(pair<string, int>("RR", 2));
	typemap.insert(pair<string, int>("LR", 3));
	typemap.insert(pair<string, int>("RL", 4));
	for (int i = 0; i < len; i++) {
		//创建节点
		AVLNode* q = new AVLNode();
		q->e = arr[i];
		q->bf = 0;
		q->h = 0;
		q->LChild = NULL;
	    q->RChild = NULL;
		//从根节点开始搜索
		if (T->root==NULL) {
			T->root = q;
			continue;
		}
		AVLNode* p = T->root;
		stack<AVLNode*> s; //C++ STL 的stack
		while (p != NULL) {
			s.push(p);
			p = arr[i] > p->e ? p->RChild : p->LChild;
		}
		p = s.top();
		arr[i] > p->e ? p->RChild = q : p->LChild = q;  // a>b ? c:d; 判断a>b,如果为真，执行c,否则执行d
		//更新可能受影响的节点的平衡因子和子树树深
		AVLNode* T3 = new AVLNode(); //记住不平衡的子树树根T3
		AVLNode* T4 = new AVLNode(); //记住不平衡的子树树根T3的父亲节点T4
		while (!s.empty()) {
			p = s.top();
			s.pop();
			if (T3->e != 0 && T4->e == 0) {
				T4 = p;
				break;
			}
			if (p->LChild != NULL && p->RChild != NULL) {
				p->h = max(p->LChild->h, p->RChild->h)+1;
				p->bf = p->LChild->h - p->RChild->h;
			}
			else {
				if (p->LChild != NULL) {
					p->h = p->LChild->h+1;
					p->bf = p->LChild->h-(-1);
				}
				else {
					p->h = p->RChild->h + 1;
					p->bf = -1-p->RChild->h;
				}
			}
			if (abs(p->bf) == 2 && T3->e==0)
				T3 = p;
		}
		//调整二叉搜索树保证平衡性
		if (T3->e!= 0) {  //存在不平衡的子树
			//判断插入类型
			AVLNode* T2 = arr[i] > T3->e ? T3->RChild : T3->LChild;
			AVLNode* T1 = arr[i] > T2->e ? T2->RChild : T2->LChild;
			string str = "";
			str += arr[i] > T3->e ? 'R' : 'L';
			str += arr[i] > T2->e ? 'R' : 'L';
			//自旋
			switch (typemap[string(str)]) {   //C++的switch(expressiom) 要求expression必须是一个整数或枚举类型
			case 1: 
				T2->RChild = T3;
				if (T4->e == 0)
					T->root = T2;
				else
					T3->e > T4->e ? T4->RChild = T2 : T4->LChild = T2;
				break;
			case 2:
				T2->LChild = T3;
				if (T4->e == 0)
					T->root = T2;
				else
					T3->e > T4->e ? T4->RChild = T2 : T4->LChild = T2;
				break;
			case 3:
				T2->RChild = T1->LChild;
				T3->LChild = T1->RChild;
				T1->LChild = T2;
				T1->RChild = T3;
				if (T4->e == 0)
					T->root = T1;
				else
					T3->e > T4->e ? T4->RChild = T1 : T4->LChild = T1;
				break;
			case 4:
				T2->LChild = T1->RChild;
				T3->RChild = T1->LChild;
				T1->RChild = T2;
				T1->LChild = T3;
				if (T4->e == 0)
					T->root = T1;
				else
					T3->e > T4->e ? T4->RChild = T1 : T4->LChild = T1;
				break;
			default: break;
			}
			//更新T1,T2,T3的树深
			while(!s.empty()) s.pop();
			s.push(T1);
			s.push(T2);
			s.push(T3);
			while (s.size() > 0) {
				p = s.top();
				s.pop();
				if (p->LChild == NULL && p->RChild == NULL) {
					p->h = 0;
					p->bf = 0;
				}
				else if (p->LChild != NULL && p->RChild != NULL) {
					p->h = max(p->LChild->h, p->RChild->h) + 1;
					p->bf = p->LChild->h - p->RChild->h;
				}
				else {
					if (p->LChild != NULL) {
						p->h = p->LChild->h + 1;
						p->bf = p->LChild->h - (-1);
					}
					else {
						p->h = p->RChild->h + 1;
						p->bf = -1 - p->RChild->h;
					}
				}
			}
		}
	}
}

//前序遍历AVL：递归
void PreOrderTraverse(AVLNode* p) {
	if (p != NULL) {
		std::cout << p->e << " " << p->h << " " << p->bf << "\n";
		PreOrderTraverse(p->LChild);
		PreOrderTraverse(p->RChild);
	}
}

int main() {
	int len = 6;
	int a[6] = { 5,3,9,7,8,6 };
	int* arr = a;
	AVLTree* T = new AVLTree();
	createAVL(T, arr, len);
	PreOrderTraverse(T->root);
}