AvlTree Insert(ElementType X,AvlTree T){
//T为空树
if(T == NULL){
T = malloc(sizeof(AvlTree));
if(T == NULL){
fatalError("out of space");
}
T -> Element = X;
T -> Left = NULL;
T -> Right = NULL;
}
//此处遇到问题 应该如何分情况讨论呢 我需求的是X插入位置的节点情况 但是此时只有根节点T
//所以插入应该递归地分左右插入 并且在插入后计算高度差值 差值2位中断情况
if(X < T-> Element){
//再次遇到问题 用什么变量存left 要不要return
//答案是直接递归修改left的值 最终改变的是叶节点指针 而非根节点
T -> Left = Insert(X , T -> Left);
if(Height(T->Left) - Height(T->Right) == 2){
//分情况
if(X < T->Left->Element){
T = SingleRotateWithLeft(T);
}else{
T = DoubleRotateWithLeft(T);
}
}
}else{
}
return T;
}
AvlTree Insert(int x, AvlTree root){
if(root==NULL){
root = (AvlNode *)malloc(sizeof(AvlNode));
if(root == NULL){
printf("Out of memory");
}else{
root->val = x;
root->right = root->left = NULL;
}
} else if(x < root->val){
root->left = Insert(x, root->left);
if(Height(root->left)-Height(root->right) == 2){
if(x<root->left->val)
root = SingleRotateWithLeft(root);
else
root = DoubleRotateWithLeft(root);
}
} else if(x > root->val){
root->right = Insert(x, root->right);
if(Height(root->right)-Height(root->left) == 2){
if(x>root->right->val)
root = SingleRotateWithRight(root);
else
root = DoubleRotateWithRight(root);
}
}
root->height = Max(Height(root->left), Height(root->right)) + 1;
return root;
}
/*
* 此函数用于当 如果 k4有一个右孩子，以及
* 它的右孩子又有左孩子，执行这个双旋转
* 更新高度，返回新的根节点
*/
static Position DoubleRotateRight(Position k4) // RL旋转
{
//在 k4 的右孩子，执行左侧单旋转
k4->right = SingleRotateWithLeft(k4->right);
// 再对 k4 进行 右侧单旋转
return SingleRotateWithRight(k4);
}
AvlTree Insert(ElementType e, AvlTree t)
{
if(t == NULL){
t = malloc(sizeof(struct AvlNode));
t->e = e;
t->height = 0;
t->left = NULL;
t->right = NULL;
}
if(e < t->e){
t->left = Insert(e, t->left);
if(Height(t->left) - Height(t->right) == 2){
if(e < t->left->e){
t = SingleRotateWithLeft(t);
}else{
t = DoubleRotateWithLeft(t);
}
}
}else if(e > t->e){
t->right = Insert(e, t->right);
if(Height(t->right) - Height(t->left) == 2){
if(e > t->right->e){
t = SingleRotateWithRight(t);
}else{
t = DoubleRotateWithRight(t);
}
}
}
t->height = Max(Height(t->left), Height(t->right)) + 1;
return t;
}
AATree
Skew( AATree T )
{
if( T->Left->Level == T->Level )
T = SingleRotateWithLeft( T );
return T;
}
/*
* 此函数用于当 如果 k3有一个左孩子，以及
* 它的左孩子又有右孩子，执行这个双旋转
* 更新高度，返回新的根节点
*/
static Position DoubleRotateLeft(Position k3) // LR旋转
{
//在 k3 的左孩子，执行右侧单旋转
k3->left=SingleRotateWithRight(k3->left);
// 再对 k3 进行 左侧单旋转
return SingleRotateWithLeft(k3);
}
static Position DoubleRotateWithRight( Position K1 )
{
/* Rotate between K3 and K2 */
K1->Right = SingleRotateWithLeft( K1->Right );
/* Rotate between K1 and K2 */
return SingleRotateWithRight( K1 );
}
static Position DoubleRotateWithLeft(Position K3)
{
/*Rotate between K1 and K2*/
K3->Left = SingleRotateWithRight(K3->Left);
/*Rotate between K3 and K2*/
return SingleRotateWithLeft(K3);
}
/*Insert X in appropriate position of T*/
AVLTree
Insert(ElementType X,AVLTree T){
/*Time to insert*/
if(T == NULL){
/*Make a node first*/
T = malloc(sizeof(struct AVLTreeNode));
if(T == NULL){
printf("ERROR! Out of memory.");
exit(0);
}
T->Element = X;
T->Height = 0;
T->Left = T->Right = NULL;
}
else
if(X < T->Element){
T->Left = Insert(X,T->Left);
/*Check balance:*/
/*If T is left heavy*/
if(Height(T->Left) - Height(T->Right) == 2){
if(X < T->Left->Element){
/*If T's left subtree is left heavy,
Just Single Rotate With Right.*/
T = SingleRotateWithRight(T);
}
else{
/*T's left subtree is right heavy,
Then Double Rotate With Left-Right.*/
T = DoubleRotateWithLeftRight(T);
}
}
}
else
if(X > T->Element){
T->Right = Insert(X,T->Right);
/*Check balance:*/
/*If T is right heavy*/
if(Height(T->Right) - Height(T->Left) == 2){
if(X > T->Right->Element){
/*If T's right subtree is right heavy,
Just Single Rotate With Left.*/
T = SingleRotateWithLeft(T);
}
else{
/*T's right subtree is left heavy,
Then Double Rotate With Right-Left.*/
T = DoubleRotateWithRightLeft(T);
}
}
}
/*Handle the height*/
T->Height = 1 + (MAX(Height(T->Left),Height(T->Right)));
return T;
}
AvlTree
Insert(ElementType X, AvlTree T)
{
if (T == NULL)
{
T = malloc(sizeof(struct AvlNode));
if (T == NULL)
{
Error("No additional memory!!");
exit(1);
}
else {
T->Element = X;
T->Height = 0;
T->Left = T->Right = NULL;
}
}
else
if (X < T->Element){
T->Left = Insert(X, T->Left);
if (Height(T->Left) - Height(T->Right) == 2)
{
if(X < T->Left->Element)
{
T = SingleRotateWithLeft(T);
}
else
{
T = DoubleRotateWithLeft(T);
}
}
}
else
if (X > T->Element)
{
T->Right = Insert(X, T->Right);
// printf("%d%s%d\n", Height(T->Right) - Height(T->Left), "Right", X);
if (Height(T->Right) - Height(T->Left) == 2)
{
// printf("%d|%d\n", X, T->Right->Element);
if (X > T->Right->Element)
{
T = SingleRotateWithRight(T);
}
else
{
T = DoubleRotateWithRight(T);
}
}
}
T->Height = Max(Height(T->Left), Height(T->Right)) + 1;
return T;
}
//删除操作类似于二叉树的操作，只是需要将树调整平衡
AvlTree DeleteFromAvlTree(ElementType x, AvlTree avltree) {
Position temp;
if (avltree == NULL)
return NULL;
//在左子树寻找删除位置，删除后可能导致左子树高度变小，可能要调整树
if (x < avltree->element) {
avltree->left = DeleteFromAvlTree(x, avltree->left);
//如果右子树高度比左子树高度超过1，那么需要将树调整平衡，这几个调整平衡的语句可以封装下
if (2 == (HeightAvlTree(avltree->right) - HeightAvlTree(avltree->left))) {
//如果是右-左型，则要进行左单旋、右单旋；即进行如下双旋操作
//否则为右-右型，需要进行左单旋操作
if (HeightAvlTree(avltree->right->left) > HeightAvlTree(avltree->right->right))
avltree = DoubleRotateWithRight(avltree);
else
avltree = SigleRotateWithRight(avltree);
}
}
//在右子树寻找删除位置，删除后可能导致右子树高度变小，可能要调整树
else if (x > avltree->element) {
avltree->right = DeleteFromAvlTree(x, avltree->right);
//这几个调整平衡的语句可以封装下
if (2 == (HeightAvlTree(avltree->left) - HeightAvlTree(avltree->right))) {
if (HeightAvlTree(avltree->left->right) > HeightAvlTree(avltree->left->left))
avltree = DoubleRotateWithLeft1(avltree);
else
avltree = SingleRotateWithLeft(avltree);
}
}
//找到要删除的元素,该节点有两个孩子
//那么将节点的值用右子树中最小的值A替换，然后在右子树中删除A
else if (avltree->left && avltree->right){
avltree->element = (FindMinFromAvlTree(avltree->right))->element;
avltree->right = DeleteFromAvlTree(avltree->element, avltree->right);
}
//找到要删除的节点，该节点为叶子节点或仅有一个孩子
else {
temp = avltree;
if (avltree->left == NULL) //当节点只有右孩子或为叶节点时
avltree = avltree->right;
else if (avltree->right == NULL) //当节点只有左孩子时
avltree = avltree->left;
free(temp);
}
if (avltree)
avltree->height = Max(HeightAvlTree(avltree->right), HeightAvlTree(avltree->left)) + 1;
return avltree;
}
struct AvlTreeNode *CAvlTree::InsertNode(const int key
, struct AvlTreeNode *node)
{
if (node == NULL)
{
node = new struct AvlTreeNode;
if (node == NULL)
{
std::cerr << "out of memory" << std::endl;
}
else
{
node->key = key;
node->height = 0;
node->left = node->right = NULL;
}
}
else if (key < node->key)
{
node->left = this->InsertNode(key, node->left);
if (this->Height(node->left) - this->Height(node->right) >= 2)
{
if (key < node->left->key)
{
node = SingleRotateWithLeft(node);
}
else
{
node = DoubleRotateWithLeft(node);
}
}
}
else if (key > node->key)
{
node->right = this->InsertNode(key, node->right);
if (this->Height(node->right) - this->Height(node->left) >= 2)
{
if (key > node->right->key)
node = SingleRotateWithRight(node);
else
node = DoubleRotateWithRight(node);
}
}
/// \note else key is in the tree already, we will do nothing.
node->height = std::max(this->Height(node->left)
, this->Height(node->right)) + 1;
return node;
}
/*Double Rotate With Right-Left, handle R-L heavy type*/
static Position
DoubleRotateWithRightLeft(Position Root){
Position RightSubRoot;
RightSubRoot = Root->Right;
/*First Rotate , Right Subtree Right Rotate*/
Root->Right = RightSubRoot->Left;
RightSubRoot->Left = Root->Right->Right;
Root->Right->Right = RightSubRoot;
/*Handle the height*/
Root->Right->Right->Height = 1 + (MAX(Height(Root->Right->Right->Left),
Height(Root->Right->Right->Right)));
Root->Right->Height = 1 + (MAX(Height(Root->Right->Left),
Height(Root->Right->Right)));
Root->Height = 1 + (MAX(Height(Root->Left),Height(Root->Right)));
/*Second Rotate With Left And Return*/
return SingleRotateWithLeft(Root);
}
void insert_tree(int data,AVLTree &node)
{
if (node == NULL)
{
node = (AVL*)malloc(sizeof(AVL));
node->data = data;
node->height = 0;
node->lchild = node->rchild = NULL;
printf("test01\n");
return;
}
else if (data < node->data)
{
insert_tree(data, node->lchild);
}
else if (data > node->data)
{
insert_tree(data, node->rchild);
}
node->height = Max(Height(node->lchild), Height(node->rchild)) + 1;
if (Height(node->lchild) - Height(node->rchild) == 2)
{
if (node->lchild->data > data)
{
SingleRotateWithLeft(node);
}
else
{
DoubleRotateWithLeft(node);
}
}
else if (Height(node->rchild) - Height(node->lchild) == 2)
{
if (node->rchild->data < data)
{
SingleRotateWithRight(node);
}
else
{
DoubleRotateWithRight(node);
}
}
}
static SplayTree *Splay(Kmer * kmer, SplayTree * T)
{
SplayNode Header;
SplayNode *LeftTreeMax, *RightTreeMin;
if (T == NULL)
return NULL;
Header.left = Header.right = NULL;
LeftTreeMax = RightTreeMin = &Header;
while (compareKmers(kmer, &(T->kmer))) {
if (compareKmers(kmer, &(T->kmer)) < 0) {
if (T->left == NULL)
break;
if (compareKmers(kmer, &(T->left->kmer)) < 0)
T = SingleRotateWithLeft(T);
if (T->left == NULL)
break;
/* Link right */
RightTreeMin->left = T;
RightTreeMin = T;
T = T->left;
} else {
if (T->right == NULL)
break;
if (compareKmers(kmer, &(T->right->kmer)) > 0)
T = SingleRotateWithRight(T);
if (T->right == NULL)
break;
/* Link left */
LeftTreeMax->right = T;
LeftTreeMax = T;
T = T->right;
}
} /* while kmer != T->kmer */
/* Reassemble */
LeftTreeMax->right = T->left;
RightTreeMin->left = T->right;
T->left = Header.right;
T->right = Header.left;
return T;
}
SplayTree
Splay( ElementType Item, Position X )
{
static struct SplayNode Header;
Position LeftTreeMax, RightTreeMin;
Header.Left = Header.Right = NullNode;
LeftTreeMax = RightTreeMin = &Header;
NullNode->Element = Item;
while( Item != X->Element )
{
if( Item < X->Element )
{
if( Item < X->Left->Element )
X = SingleRotateWithLeft( X );
if( X->Left == NullNode )
break;
/* Link right */
RightTreeMin->Left = X;
RightTreeMin = X;
X = X->Left;
}
else
{
if( Item > X->Right->Element )
X = SingleRotateWithRight( X );
if( X->Right == NullNode )
break;
/* Link left */
LeftTreeMax->Right = X;
LeftTreeMax = X;
X = X->Right;
}
} /* while Item != X->Element */
/* Reassemble */
LeftTreeMax->Right = X->Left;
RightTreeMin->Left = X->Right;
X->Left = Header.Right;
X->Right = Header.Left;
return X;
}
/*
* 对单个节点进行的AVL调整
*/
AvlTree Rotate(AvlTree T)
{
if(Height(T->left) - Height(T->right) == 2)
{
if(Height(T->left->left) >= Height(T->left->right))
T = SingleRotateWithLeft(T); // LL旋转
else
T = DoubleRotateLeft(T); // LR旋转
}
if(Height(T->right) - Height(T->left) == 2)
{
if(Height(T->right->right) >= Height(T->right->left))
T = SingleRotateWithRight(T); // RR旋转
else
T = DoubleRotateRight(T); // RL旋转
}
return T;
}
/*
* 向AVL树插入可以通过如同它是未平衡的二叉查找树一样把给定的值插入树中，
* 接着自底向上向根节点折回，于在插入期间成为不平衡的所有节点上进行旋转来完成。
* 因为折回到根节点的路途上最多有1.5乘log n个节点，而每次AVL旋转都耗费恒定的时间，
* 插入处理在整体上耗费O(log n) 时间。
*/
AvlTree Insert(ElementType x,AvlTree T)
{
//如果T不存在，则创建一个节点树
if(T == NULL)
{
T = (AvlTree)malloc(sizeof(struct AvlNode));
{
T->data = x;
T->Height = 0;
T->left = T->right = NULL;
}
}
// 如果要插入的元素小于当前元素
else if(x < T->data)
{
//递归插入
T->left=Insert(x,T->left);
//插入元素之后，若 T 的左子树比右子树高度 之差是 2，即不满足 AVL平衡特性，需要调整
if(Height(T->left) - Height(T->right) == 2)
{
//把x插入到了T->left的左侧，只需 左侧单旋转
if(x < T->left->data)
T = SingleRotateWithLeft(T); // LL旋转
else
// x 插入到了T->left的右侧，需要左侧双旋转
T = DoubleRotateLeft(T); // LR旋转
}
}
// 如果要插入的元素大于当前元素
else if(x > T->data)
{
T->right=Insert(x,T->right);
if(Height(T->right) - Height(T->left) == 2)
{
if(x > T->right->data)
T = SingleRotateWithRight(T); //RR 旋转
else
T = DoubleRotateRight(T); //RL旋转
}
}
T->Height=Max(Height(T->left),Height(T->right)) + 1;
return T;
}
AvlTree Insert( ElementType X, AvlTree T )
{
if( T == NULL )
{
/* Create and return a one-node tree */
T = malloc( sizeof( struct AvlNode ) );
T->Element = malloc(sizeof(int)*RULE_SIZE);
if( T == NULL )
FatalError( "Out of space!!!" );
else
{
memcpy(T->Element,X,RULE_SIZE*sizeof(int));
T->Height = 0;
T->Left = T->Right = NULL;
}
}
else
if(compareLeaf(X, T->Element)==-1 )
{
T->Left = Insert( X, T->Left );
if( Height( T->Left ) - Height( T->Right ) == 2 )
if( compareLeaf(X,T->Left->Element)==-1 )
T = SingleRotateWithLeft( T );
else
T = DoubleRotateWithLeft( T );
}
else
if( compareLeaf(X,T->Element)==1 )
{
T->Right = Insert( X, T->Right );
if( Height( T->Right ) - Height( T->Left ) == 2 )
if( compareLeaf(X,T->Right->Element)==1 )
T = SingleRotateWithRight( T );
else
T = DoubleRotateWithRight( T );
}
/* Else X is in the tree already; we'll do nothing */
T->Height = Max( Height( T->Left ), Height( T->Right ) ) + 1;
return T;
}
Treap remove(Treap T, int item)
{
if (T != Null_node)
{
if (item < T->element)
{
T->left = remove(T->left, item);
}
else if(item > T->element)
{
T->right = remove(T->right, item);
}
else
{
/*match found*/
{
if (T->left->priority < T->right->priority)
{
T = SingleRotateWithLeft(T);
}
else
{
T = SingleRotateWithRight(T);
}
if (T != Null_node)
{
T = remove(T, item);
}
else
{
/* at a leaf */
free(T->left);
T->left = Null_node;
}
}
}
}
return T;
}
//先把书上的avl插入函数手打一遍
AvlTree Insert(ElementType X, AvlTree T)
{
if(T == NULL)
{
T = (AvlTree*)malloc(sizeof(struct AvlTree));
if(T == NULL)
printf("Out of space!\n");
else
{
T->Height = 0;
T->Right = NULL;
T->Left = NULL;
T->Element = X;
}
}
else if(X < T->Element)
{
T->Left = Insert(X, T->Left);
if(Height(T->Left) - Height(T->Right) == 2)
if(X < T->Left->Element)
SingleRotateWithLeft(T->Left);
else
DoubleRotateWithLeft(T->Left);
}
else if(X > T->Element)
{
T->Right = Insert(X, T->Right);
if(Height(T->Right) - Height(T->Left) == 2)
if(X > T->Right->Element)
SingleRotateWithRight(T->Right);
else
DoubleRotateWithRight(T->Right);
}
T->Height = Max(Height(T->Left), Height(T->Right)) + 1;
return T;
}
AvlTree InsertToAvlTree(ElementType x, AvlTree avltree) {
if (avltree == NULL) { //如果树为空，分配空间，插入节点
avltree = (struct AvlNode*)malloc(sizeof(struct AvlNode));
if (avltree == NULL) {
cout << "malloc failed." << endl;
}
else {
avltree->element = x;
avltree->left = avltree->right = NULL;
}
}
//插入值小于根节点的值，在左子树插入节点
else if (x < avltree->element) {
avltree->left = InsertToAvlTree(x, avltree->left);
//树失去了平衡，对树进行调整，这几个调整平衡的语句可以封装下
if (HeightAvlTree(avltree->left) - HeightAvlTree(avltree->right) == 2) {
if (x < avltree->left->element) //左-左，进行左单旋转
avltree = SingleRotateWithLeft(avltree);
else //左-右，双旋转
avltree = DoubleRotateWithLeft1(avltree);
}
}
//插入值大于根节点的值，在右子树插入节点
else if (x > avltree->element) {
avltree->right = InsertToAvlTree(x, avltree->right);
//树失去了平衡，对树进行调整，这几个调整平衡的语句可以封装下
if (HeightAvlTree(avltree->right) - HeightAvlTree(avltree->left) == 2) {
if (x > avltree->right->element)
avltree = SigleRotateWithRight(avltree); //右-右，单旋转
else //右-左，双旋转
avltree = DoubleRotateWithRight(avltree);
}
}
avltree->height = Max(HeightAvlTree(avltree->left), HeightAvlTree(avltree->right)) + 1;
return avltree;
}
AvlTree Insert(ElementType X, AvlTree T)
{
if(T == NULL)
{
T = malloc(sizeof(struct AvlNode));
if(T == NULL)
FatalError("Out of space!!!");
else
{
T->Element = X;
T->Height = 0;
T->Left = T->Right = NULL;
}
}
else if(X < T->Element)
{
T->Left = Insert(X, T->Left);
if(Height(T->Left) - Height(T->Right) == 2)
if(X < T->Left->Element)
T = SingleRotateWithLeft(T);
else
T = DoubleRotateWithLeft(T);
}
else if(X > T->Element)
{
T->Right = Insert(X, T->Right);
if(Height(T->Right) - Height(T->Left) == 2)
if(X > T->Right->Element)
T = SingleRotateWithRight(T);
else
T = DoubleRotateWithRight(T);
}
T->Height = Max(Height(T->Left), Height(T->Right)) + 1;
return T;
}
void DoubleRotateWithRight(AVLTree& node)
{
SingleRotateWithLeft(node->rchild);
SingleRotateWithRight(node);
}
static Position DoubleRotateWithRight(Position K3)
{
K3-Right = SingleRotateWithLeft(K3->Right);
return SingleRotateWithRight(K3);
}
//左-右插入，使得k3失去平衡，因此在k3处双旋转
//双旋转其实是两次单旋转操作
//先对k3的左子树进行一次右-右单旋转操作
//然后对k3进行一次左-左单旋转操作
static Position DoubleRotateWithLeft1(Position k3) { //双旋转，递归
k3->left = SigleRotateWithRight(k3->left);
return SingleRotateWithLeft(k3);
}
void delete_node(AVLTree& root, int data)
{
if (root == NULL) {
printf("NULL to delete\n");
return;
}
if (root->data == data) {
AVLTree node = root;
printf("begin to delete\n");
if (root->lchild == NULL && root->rchild == NULL)
{
root = NULL;
}
else if(root->rchild != NULL && root->lchild != NULL)
{
AVLTree loop = root->rchild;
while (loop->lchild != NULL) {
loop = loop->lchild;
}
root->data = loop->data;
delete_node(root->rchild, loop->data);
}
else
{
if (root->lchild == NULL) {
root = root->rchild;
}
else
{
root = root->lchild;
}
}
free(node);
}
else if (root->data < data)
{
delete_node(root->rchild, data);
}
else
{
delete_node(root->lchild, data);
}
if (root == NULL) {
return;
}
root->height = Max(Height(root->lchild), Height(root->rchild)) + 1;
if (Height(root->lchild) - Height(root->rchild) == 2)
{
if (Height(root->lchild->lchild) > Height(root->lchild->rchild))
{
SingleRotateWithLeft(root);
}
else
{
DoubleRotateWithLeft(root);
}
}
if (Height(root->rchild) - Height(root->lchild) == 2)
{
if (Height(root->rchild->rchild) > Height(root->rchild->lchild))
{
SingleRotateWithRight(root);
}
else
{
DoubleRotateWithRight(root);
}
}
}
//右-左插入，使得k1失去平衡，因此在k1处双旋转
//双旋转其实是两次单旋转操作
//先对k1的右子树进行一次左-左单旋转操作
//然后对k1进行一次右-右单旋转操作
static Position DoubleRotateWithRight(Position k1) {
k1->right = SingleRotateWithLeft(k1->right);
return SigleRotateWithRight(k1);
}
Position
DoubleRotateWithLeft(Position K3)
{
SingleRotateWithRight(K3->Left);
return SingleRotateWithLeft(K3);
}
static Position DoubleRotateWithRight(Position k3)
{
k3->right = SingleRotateWithLeft(k3->right);
return SingleRotateWithRight(k3);
}
