CayAVL }

void init(NodePtr &r) { void duyetLNR(NodePtr r){

r = NULL; if (r != NULL) {

} cout << r->data << " ";

int Empty(NodePtr r) duyetLNR(r->left);

{ duyetLNR(r->right);

if (r == NULL) }

return 1; }

else int timA(NodePtr r, int a) {

return 0; if (r == NULL) return NULL;

} if (a == r->data) {

NodePtr createNode(int a) { return a;

NodePtr p = new Node; }

p->data = a; else if (a < r->data) {

p->left = NULL; timA(r->left, a);

p->right = NULL; }

return p; else {

} timA(r->right, a);

void chen(NodePtr& r, int a) { }

if (r == NULL) {

r = createNode(a); }

} int xoaA(NodePtr& r, int a) {

else if (a == r->data) { NodePtr p, q, t, f;

cout << "\n Node already exists"; p = r;

return; t = NULL;

} f = NULL;

else { while (p != NULL) {

if (a < r->data) { if (p->data == a)break;

chen(r->left, a); else {

} if (a < p->data) {

else { f = p;

chen(r->right, a); p = p->left;

} }

} else {
 f = p; }

p = p->right; if (f->right == p) {

} f->right
= NULL;
}
}
}
}
if (p == NULL)
delete p;
return 0;
return 1;
else {
}
if (p->left != NULL && p->right !=
NULL) { }

q = p->right; }

t = p; Cay AVL

while (q->left != NULL) { void init(AVLTREE& T)

t = q; {

q = q->left; T = NULL;

} }

p->data = q->data; AVLTREE CreateNodeAVL(int info)

if (t->left == q) {

t->left = NULL; AVLTREE p = new NODEAVL;

if (t->right == q) p->info = info;

t->right = NULL; p->left = NULL;

p = q; p->right = NULL;

} p->height = 1;

if (p->left != NULL) return p;

q = p->left; }

else void NLR(AVLTREE T)

q = p->right; {

if (p == r) if (T != NULL) {

r = NULL; cout << T->info << " ";

else if (p->left == NULL && p->right NLR(T->left);

== NULL) {
NLR(T->right);
if (f != NULL) {
}
if (f->left == p) {
}
f->left =
NULL; void LNR(AVLTREE T)
{ {

if (T != NULL) { if (T == NULL || T->left == NULL) return;

LNR(T->left); AVLTREE p = T->left;

cout << T->info << " "; T->left = p->right;

LNR(T->right); p->right = T;

} T = p;

void LRN(AVLTREE T) }

{ void RotateLeft(AVLTREE& T)

if (T != NULL) { {

LNR(T->left); if (T == NULL || T->right == NULL) return;

LNR(T->right); AVLTREE p = T->right;

cout << T->info << " "; T->right = p->left;

p->left = T;

} T = p;

int Max(int a, int b) }

{ void RotateRightLeft(AVLTREE& T)

return (a > b) ? a : b; {

} if (T == NULL || T->right == NULL||T->left ==

NULL) return;
int height(AVLTREE T)
RotateRight(T->right);
{
RotateLeft(T);
if (T == NULL)
}
return 0;
void RotateLeftRight(AVLTREE& T)
return 1 + Max(height(T->left), height(T-
>right)); {

} if (T == NULL || T->left == NULL || T->right ==

NULL) return;
int getCB(AVLTREE T)
RotateLeft(T->left);
{
RotateRight(T);
if (T == NULL)
}
return 0;
void them(AVLTREE& T,int x) {
return height(T->left) - height(T->right);
if (T == NULL) {
}
T = CreateNodeAVL(x);
void RotateRight(AVLTREE& T)
return;
 } current = current->left;

if (x < T->info) return current;

them(T->left, x); }

else if (x > T->info) AVLTREE search(AVLTREE T, int x)

them(T->right, x); {

else if (T == NULL || T->info == x)

return; return T;

T->height = 1 + Max(height(T->left), height(T- if (x < T->info)

>right));
return search(T->left, x);

int cb = getCB(T);
return search(T->right, x);

int DeleteNode(AVLTREE &T, int x)

if (cb > 1 && x < T->left->info)
{
RotateRight(T);
if (T == NULL)

return 0;
else if (cb < -1 && x > T->right->info)

RotateLeft(T);
if (x < T->info)

DeleteNode(T->left, x);
else if (cb > 1 && x > T->left->info) {

RotateLeft(T->left);
else if (x > T->info)
RotateRight(T);
DeleteNode(T->right, x);
}

else {
else if (cb < -1 && x < T->right->info) {
if (T->left == NULL || T->right ==
RotateRight(T->right); NULL) {

RotateLeft(T); AVLTREE temp = T->left ?

T->left : T->right;
}
if (temp == NULL) {
}
temp = T;
AVLTREE minValueNODEAVL(AVLTREE T)
T = NULL;
{
}
AVLTREE current = T;
else {
while (current->left != NULL)
*T = *temp;
 } else if (cb < -1 && getCB(T->right) > 0) {

delete temp; RotateRight(T->right);

} RotateLeft(T);

else { }

AVLTREE temp = T->right;

while (temp->left != NULL) return 1;

temp = temp- }
>left;
Cay tan loe

void preOrder(Node* root)

T->info = temp->info;
{

if (root != NULL)
DeleteNode(T->right,
temp->info); {

} cout << root->key << " ";

} preOrder(root->left);

preOrder(root->right);

if (T == NULL) }

return 1; }

NodePtr createNode(int x)

T->height = 1 + Max(height(T->left), height(T- {

>right));
NodePtr p = new Node();

p->key = x;
int cb = getCB(T);
p->left = p->right = NULL;

return p;
if (cb > 1 && getCB(T->left) >= 0)
}
RotateRight(T);
void splayToRoot(NodePtr& r, NodePtr node)

{
else if (cb > 1 && getCB(T->left) < 0) {
while (node != NULL)
RotateLeft(T->left);
{
RotateRight(T);
node = splay(r, node);
}
}

}
else if (cb < -1 && getCB(T->right) <= 0)
NodePtr find(NodePtr r, int x)
RotateLeft(T);
{

if (r == NULL || r->key == x)
 return r; return r;

if (r->key < x) }

return find(r->right, x); else if (r->right == nodeX)

return find(r->left, x); {

} //Zig: quay trái

NodePtr findAndSplay(NodePtr r, int x) rotateLeft(r);

{ return r;

NodePtr node = find(r, x); }

splayToRoot(r, node); else

return node; {

} NodePtr p;

void rotateRight(NodePtr& r) if (nodeX->key < r->key)

{ {

if (r == NULL || r->left == NULL) return; p = r->left;

NodePtr p = r->left; if (p == NULL) return

NULL;
r->left = p->right;
if (p->left == nodeX) //Zig-
p->right = r; Zig:
r = p; {
} rotateRight(r);
void rotateLeft(NodePtr& r) rotateRight(r);
{ return r;
if (r == NULL || r->right == NULL) return; }
NodePtr p = r->right; else if (p->right == nodeX)
//Zig-Zag:
r->right = p->left;
{
p->left = r;
rotateLeft(r->left);
r = p;
rotateRight(r);
}
return r;
NodePtr splay(NodePtr& r, NodePtr nodeX)
}
{
else {
if (r == NULL) return NULL;
return splay(r-
if (r->left == nodeX)
>left, nodeX);
{
}
//Zig: Quay phải
}
rotateRight(r);
 else if (nodeX->key > r->key) q = p;

{ if (x < p->key)

p = r->right; p = p->left;

if (p == NULL) return else if (x > p->key) {

NULL;
p = p->right;
if (p->right == nodeX)
//Zig-Zig: }

{ else

rotateLeft(r); splayToRoot(r,q);

rotateLeft(r); return r;

return r; }

} NodePtr t = createNode(x);

else if (p->left == nodeX) if (q != NULL) {

//Zig-Zag:
if (x < q->key)
{
q->left = t;
rotateRight(r-
else
>right);
q->right = t;
rotateLeft(r);
splayToRoot(r, t);
return r;
}
}
else {
else {
r = t;
return splay(r-
>right, nodeX); }
} return r;
} }
else return NULL; NodePtr deleteNodeAndSplay(NodePtr& r, int x)
} {
} NodePtr p = find(r, x);
NodePtr insert(NodePtr& r, int x) if (p == NULL)
{ return r;
if (r == NULL) { splayToRoot(r, p);
r = createNode(x); if (r->left == NULL) {
} NodePtr term = r;
NodePtr p = r; r = r->right;
NodePtr q = NULL; delete term;
while (p != NULL) { }
 else { p->key = x;

NodePtr term = r; p->left = p->right = NULL;

NodePtr lefttree = r->left; return p;

NodePtr righttree = r->right; }

void splayToRoot(NodePtr& r, NodePtr node)

lefttree->right = NULL; {

delete term; while (node != NULL)

NodePtr maxleft = lefttree; node = splay(r, node);

while (maxleft->right != NULL); }

maxleft = maxleft->right; }

NodePtr find(NodePtr r, int x)

splayToRoot(lefttree, maxleft); {

if (r == NULL || r->key == x)

lefttree->right = righttree; return r;

r = lefttree; if (r->key < x)

} return find(r->right, x);

return r; return find(r->left, x);

} }

void init(NodePtr& root) { NodePtr findAndSplay(NodePtr r, int x)

root = NULL; {

} NodePtr node = find(r, x);

void preOrder(Node* root) splayToRoot(r, node);

{ return node;

if (root != NULL) }

{ void rotateRight(NodePtr& r)

cout << root->key << " "; {

preOrder(root->left); if (r == NULL || r->left == NULL) return;

preOrder(root->right); NodePtr p = r->left;

} r->left = p->right;

} p->right = r;

NodePtr createNode(int x) r = p;

{ }

NodePtr p = new Node(); void rotateLeft(NodePtr& r)

{ return r;

if (r == NULL || r->right == NULL) return; }

NodePtr p = r->right; else if (p->right == nodeX)

//Zig-Zag:
r->right = p->left;
{
p->left = r;
rotateLeft(r->left);
r = p;
rotateRight(r);
}
return r;
NodePtr splay(NodePtr& r, NodePtr nodeX)
}
{
else {
if (r == NULL) return NULL;
return splay(r-
if (r->left == nodeX) >left, nodeX);
{ }
//Zig: Quay phải }
rotateRight(r); else if (nodeX->key > r->key)
return r; {
} p = r->right;
else if (r->right == nodeX) if (p == NULL) return
NULL;
{
if (p->right == nodeX)
//Zig: quay trái
//Zig-Zig:
rotateLeft(r);
{
return r;
rotateLeft(r);
}
rotateLeft(r);
else
return r;
{
}
NodePtr p;
else if (p->left == nodeX)
if (nodeX->key < r->key) //Zig-Zag:

{ {

p = r->left; rotateRight(r-
>right);
if (p == NULL) return
NULL; rotateLeft(r);

if (p->left == nodeX) //Zig- return r;

Zig:
}
{
else {
rotateRight(r);
return splay(r-
rotateRight(r); >right, nodeX);
 } r = t;

} }

else return NULL; return r;

} }

} NodePtr deleteNodeAndSplay(NodePtr& r, int x)

NodePtr insert(NodePtr& r, int x) {

{ NodePtr p = find(r, x);

if (r == NULL) { if (p == NULL)

r = createNode(x); return r;

return r; splayToRoot(r, p);

} if (r->left == NULL) {

NodePtr p = r; NodePtr term = r;

NodePtr q = NULL; r = r->right;

while (p != NULL) { delete term;

q = p; }

if (x < p->key) else {

p = p->left; NodePtr term = r;

else if (x > p->key) { NodePtr lefttree = r->left;

p = p->right; NodePtr righttree = r->right;

else { lefttree->right = NULL;

splayToRoot(r, q); delete term;

return r;

} NodePtr maxleft = lefttree;

} while (maxleft->right != NULL);

NodePtr t = createNode(x); maxleft = maxleft->right;

if (q != NULL) {

if (x < q->key) splayToRoot(lefttree, maxleft);

q->left = t;

else lefttree->right = righttree;

q->right = t; r = lefttree;

splayToRoot(r, t); }

} return r;

else { }
Cay Nghien return root;

void Init(SkewHeap* &sh) }

{ SkewHeap* DeleteMax(SkewHeap* &root)

sh = new SkewHeap; {

sh->left = NULL; if (root == NULL) return NULL;

sh->right = NULL; SkewHeap* temp1;

} SkewHeap* temp2;

SkewHeap* Merge(SkewHeap* &h1, SkewHeap* temp1 = root->left;

&h2)
temp2 = root->right;
{
temp1 = Merge(temp1, temp2);
SkewHeap* temp;
return temp1;
if (h1 == NULL)
}
return h2;
void PreOrder(SkewHeap* root)
if (h2 == NULL)
{
return h1;
if (root != NULL) {
if (h1->key < h2->key)
cout << root->key << " ";
{
PreOrder(root->left);
temp = h1;
PreOrder(root->right);
h1 = h2;
}
h2 = temp;
}
}
Preorder node, left, right
temp = h1->left;
Inorder left, node, right
h1->left = h1->right;
Posorder left, right node
h1->right = temp;

h1->left = Merge(h2, h1->left);

return h1;

SkewHeap* Insert(SkewHeap* &root,int value)

SkewHeap* temp;

Init(temp);

temp->key = value;

root = Merge(root, temp);