AVL树 (旋转平衡树 | BST | 可持久化结构 | 结构化编程)

导入和宏架构

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <stdbool.h>
#include <utility>

#if _STDC_VERSION_ >= 201710L
# define _STDC18_ 1
#else
# define _STDC18 0
#endif

#if __has_include(<stddef>) == 0
# include <stddef>
# if _STDC18_ == 0
#  ifndef nullptr_t
#  define nullptr_t NULL
#  endif
# endif
#endif

#define max(x,y)({\
    typeof(x) _x = x; \
    typeof(y) _y = y; \
    (void) ( &_x == &_y ); \
    _x>_y?_x:_y;\
})

#define del_r \
	std::pair<node *,_Bool>
#define fir \
	first
#define sec \
	second

结构体定义

typedef 
	struct _node
	{
		int _v,//value
			_h,//height
			_c,//capacity
			_s;//size
		struct _node *_left,
					 *_right;
	}node;

enum TAGS{
	INS = 1,
	DEL = 0,
};	

函数

static
	node *_new(int v)
	{
		node *_n = (node *)malloc(sizeof(node));
		_n->_v = v;
		_n->_h = 1;
		_n->_c = 1;
		_n->_s = 1;
		_n->_left = nullptr_t;
		_n->_right = nullptr_t;
		return _n;
	}	
static 
	inline int _height(node *_n){ return !(_n == nullptr_t)? _n->_h:0;}
static 
	inline int _size(node *_r){return !(_r == nullptr_t)?_r->_s:0;}
static
	node *_leftRotat(node **_r)
	{
		node *_nr = (*_r)->_right,
			 *_t = _nr->_left;
		(*_r)->_s = _size(_t->_right)
				 	+_size((*_r)->_right)
				 	+1;
		_t->_s = _size(_t->_left)
				+_size((*_r))
				+1;
		_nr->_left = (*_r);
		(*_r)->_right = _t;
		
		
		(*_r)->_h = 1+max(_height( (*_r)->_left),
					     +_height( (*_r)->_right) );
		return _nr;
	}
static 
	node *_rightRotat(node **_r)
	{
		node *_nr = (*_r)->_left,
			 *_t = _nr->_right;
		(*_r)->_s = _size(_t->_left)
				 	+_size((*_r)->_left)
				 	+1;
		_t->_s = _size(_t->_right)
				+_size((*_r))
				+1;
		_nr->_right = (*_r);
		(*_r)->_left = _t;
		
		(*_r)->_h = 1+max(_height( (*_r)->_left),
					     +_height( (*_r)->_right) );
		return _nr;
	}
static
	inline int _bal(node *_r){return _height(_r->_left) - _height(_r->_right);}
static
	inline node *_adj(node **_r,int TAG)
	{
		node *_nr = *_r;
		int bal = _bal(*_r);
		if(bal > 1)
		{
			if(TAG?_bal((*_r)->_left) > 0:_bal((*_r)->_left) >= 0)
				_nr = _rightRotat(_r);
			else
			{
				(*_r)->_left = _leftRotat(&((*_r)->_left));
				_nr = _rightRotat(_r);
			}	
		}
		else if(bal < -1)
		{
			if(TAG?_bal((*_r)->_right) < 0:_bal((*_r)->_right) <= 0)
				_nr = _leftRotat(_r);
			else
			{
				(*_r)->_right = _rightRotat(&((*_r)->_right));
				_nr = _leftRotat(_r);
			}
		}
		return _nr;
	}
static
	node *_ins(node **_r,int v)
	{
		if(_r == nullptr_t)
			return _new(v);
		++((*_r)->_s);
		if(v < (*_r)->_v)
			(*_r)->_left = _ins(&((*_r)->_left),v);
		else if(v > (*_r)->_v)
			(*_r)->_right = _ins(&((*_r)->_right),v);
		else ++((*_r)->_c);
		(*_r)->_h = 1+max(_height( (*_r)->_left),
					     +_height( (*_r)->_right) );
		_adj(_r,INS);
		return (*_r);
	}
	
static
	node *_fnd(node *_r,int v)
	{
		if(_r == nullptr_t)return nullptr_t;
		if(v < _r->_v)return _fnd(_r->_left,v);
		if(v > _r->_v)return _fnd(_r->_right,v);
		else return _r;
	}
static
	node *__del(node **_r,int v);
static 
	_Bool _del(node **_r,int v)
	{
		_Bool ret = 0;
		node *pret = nullptr_t;
		if(!(nullptr_t == (pret = _fnd((*_r),v))))
		{
			ret = 1;
			__del(_r,v);
		}
		return ret;
	}
static
	node *__del(node **_r,int v)
	{
		
		if(v < (*_r)->_v)
		{
			--((*_r)->_s);
			(*_r)->_left = __del(&((*_r)->_left),v);
		}
		else if(v > (*_r)->_v)
		{
			
			--((*_r)->_s);
			(*_r)->_right = __del(&((*_r)->_right),v);
		}
		else
		{
			if((*_r)->_left == nullptr_t
			&& (*_r)->_right == nullptr_t)
			{
				node *_t = *_r;
				*_r = nullptr_t;
				_r = nullptr_t;
				free(_t);
			}
			else if((*_r)->_left == nullptr_t
			&& !((*_r)->_right == nullptr_t))
			{
				node *_t = *_r;
				*_r = (*_r)->_right;
				free(_t);
			}
			else if((*_r)->_right == nullptr_t
			&& !((*_r)->_left == nullptr_t))
			{
				node *_t = *_r;
				*_r = (*_r)->_left;
				free(_t);
			}
			else
			{
				node *_cur = (*_r)->_right;
				while(!(_cur->_left == nullptr_t))
					_cur = _cur->_left;
				(*_r)->_v = _cur->_v;
				(*_r)->_c = _cur->_c;
				--((*_r)->_s);
				(*_r)->_right = __del(&((*_r)->_right),_cur->_v);
			}
		}
		_adj(_r,DEL);
		return (*_r);
	}