avlcode

//////////////////////////avlAlgorithm.cpp

#include "stdafx.h"

#include<iostream>
#include "avlAlgorithm.h"


static int treeBlanch;


inline char getNodeHeavy(treeNode *AvlNode)
{
return AvlNode->NodeState;
}
inline void setNodeHeavy(treeNode *AvlNode,char change)
{
AvlNode->NodeState = change;
}


inline int cmpAb(NodeType a, NodeType b)
{
if (a > b)
{
return 1;
}
else if (a == b)
{
return 0;
}
else
{
return -1;
}
}


//treeNode::treeNode(int input) :l(NULL), r(NULL), data(input)
//{}




avlTreeManage::avlTreeManage()
{
rootAvl = NULL;
}
avlTreeManage::~avlTreeManage()
{
delAvl();
}
int avlTreeManage::findNode(NodeType Nid)
{
return find(rootAvl, Nid);
}
int avlTreeManage::find(treeNode *AvlNode, NodeType Nid)
{
if (AvlNode == NULL)
{
return 0;
}
int cmpResolt = cmpAb(Nid, AvlNode->data);
if (0 == cmpResolt)
{
return 1;
}
else if (1 == cmpResolt)
{
return find(AvlNode->r, Nid);
}
else
{
return find(AvlNode->l, Nid);
}
}


int avlTreeManage::addNode(NodeType Nid)
{
if (NULL == rootAvl)
{
rootAvl = new treeNode(Nid);
return 1;
}
else
{
treeBlanch = 0;
return addNodeToTree(rootAvl, Nid);
}
}


int avlTreeManage::addNodeToTree(treeNode *&AvlNode, NodeType Nid)
{

if (NULL == AvlNode)
{
AvlNode = new treeNode(Nid);
treeBlanch = 1;
return 1;
}
else
{
int cmpResolt = cmpAb(Nid, AvlNode->data);
int SubHeavy;
if (cmpResolt > 0)
{
if ((SubHeavy = addNodeToTree(AvlNode->r, Nid)) < 0)
{
return -1;
}
if (treeBlanch)
{
if (NodeBalance == getNodeHeavy(AvlNode))
{
setNodeHeavy(AvlNode, NoderightHeavy);
return 1;
}
if (NodeLeftHeavy == getNodeHeavy(AvlNode))
{
setNodeHeavy(AvlNode, NodeBalance);
treeBlanch = 0;
return 0;
}
//else
{
treeNode *lN = AvlNode->r;
if (NodeBalance == getNodeHeavy(lN))
{
treeBlanch = 0;
return 0;
}
if (NoderightHeavy == getNodeHeavy(lN))
{
AvlNode->r = lN->l;
lN->l = AvlNode;
setNodeHeavy(lN, NodeBalance);
setNodeHeavy(AvlNode, NodeBalance);
AvlNode = lN;
treeBlanch = 0;
return 0;
}
//else
{
treeNode *rN = lN->l;
AvlNode->r = rN->l;
lN->l = rN->r;
rN->l = AvlNode;
rN->r = lN;


if (NodeLeftHeavy == getNodeHeavy(rN))
{
setNodeHeavy(lN, NoderightHeavy);
setNodeHeavy(AvlNode, NodeBalance);
}
else if (NoderightHeavy == getNodeHeavy(rN))
{
setNodeHeavy(lN, NodeBalance);
setNodeHeavy(AvlNode, NodeLeftHeavy);
}
else if (NodeBalance == getNodeHeavy(rN))
{
setNodeHeavy(lN, NodeBalance);
setNodeHeavy(AvlNode, NodeBalance);
}
setNodeHeavy(rN, NodeBalance);
AvlNode = rN;
treeBlanch = 0;
return 0;
}
}
}
}
else if (cmpResolt < 0)
{
if ((SubHeavy = addNodeToTree(AvlNode->l, Nid)) < 0)
{
return -1;
}
if (treeBlanch)
{
if (NodeBalance == getNodeHeavy(AvlNode))
{
setNodeHeavy(AvlNode, NodeLeftHeavy);
return 1;
}
if (NoderightHeavy == getNodeHeavy(AvlNode))
{
setNodeHeavy(AvlNode, NodeBalance);
treeBlanch = 0;
return 0;
}
//else
{
treeNode *lN = AvlNode->l;
if (NodeBalance == getNodeHeavy(lN))
{
treeBlanch = 0;
return 0;
}
if (NodeLeftHeavy == getNodeHeavy(lN))
{
AvlNode->l = lN->r;
lN->r = AvlNode;
setNodeHeavy(lN, NodeBalance);
setNodeHeavy(AvlNode, NodeBalance);
AvlNode = lN;
treeBlanch = 0;
return 0;
}
//else
{
treeNode *rN = lN->r;
AvlNode->l = rN->r;
lN->r = rN->l;
rN->r = AvlNode;
rN->l = lN;


if (NodeLeftHeavy == getNodeHeavy(rN))
{
setNodeHeavy(lN, NodeBalance);
setNodeHeavy(AvlNode, NoderightHeavy);
}
else if (NoderightHeavy == getNodeHeavy(rN))
{
setNodeHeavy(lN, NodeLeftHeavy);
setNodeHeavy(AvlNode, NodeBalance);
}
else if (NodeBalance == getNodeHeavy(rN))
{
setNodeHeavy(lN, NodeBalance);
setNodeHeavy(AvlNode, NodeBalance);
}
setNodeHeavy(rN, NodeBalance);
AvlNode = rN;
treeBlanch = 0;
return 0;
}
}
}
}
else
{
return -1;
}
}


//if (treeBlanch)
//{


//}
return 1;
}




static treeNode *SelectNode = NULL;
int avlTreeManage::delNode(NodeType Nid)
{
int flag = 0;
delOneNodeFromTree(rootAvl, Nid, flag);
return flag;
}




inline int adjustTreeNodeForDel(treeNode *&AvlNode,bool Rreturn)
{
if (true == Rreturn)
{
switch (getNodeHeavy(AvlNode))
{
case NodeBalance:
setNodeHeavy(AvlNode, NodeLeftHeavy);
return 0;
case NoderightHeavy:
setNodeHeavy(AvlNode, NodeBalance);
return -1;
case NodeLeftHeavy:
{
 treeNode *lt = AvlNode->l;
 if (NodeBalance == lt->NodeState)
 {
 AvlNode->l = lt->r;
 lt->r = AvlNode;
 setNodeHeavy(AvlNode, NodeLeftHeavy);
 setNodeHeavy(lt, NoderightHeavy);
 AvlNode = lt;
 return 0;
 }
 else if (NodeLeftHeavy == lt->NodeState)
 {
 AvlNode->l = lt->r;
 lt->r = AvlNode;
 setNodeHeavy(AvlNode, NodeBalance);
 setNodeHeavy(lt, NodeBalance);
 AvlNode = lt;
 return -1;
 }
 else// if (NoderightHeavy == lt->NodeState)
 {
 treeNode *rt = lt->r;
 AvlNode->l = rt->r;
 lt->r = rt->l;
 rt->r = AvlNode;
 rt->l = lt;
 if (NodeLeftHeavy == getNodeHeavy(rt))
 {
 setNodeHeavy(lt, NodeBalance);
 setNodeHeavy(AvlNode, NoderightHeavy);
 }
 else if (NoderightHeavy == getNodeHeavy(rt))
 {
 setNodeHeavy(lt, NodeLeftHeavy);
 setNodeHeavy(AvlNode, NodeBalance);
 }
 else if (NodeBalance == getNodeHeavy(rt))
 {
 setNodeHeavy(lt, NodeBalance);
 setNodeHeavy(AvlNode, NodeBalance);
 }
 setNodeHeavy(rt, NodeBalance);
 AvlNode = rt;
 return -1;//the node tree depth -1.
 }
}
default:
break;
}
}
else
{
switch (getNodeHeavy(AvlNode))
{
case NodeBalance:
setNodeHeavy(AvlNode, NoderightHeavy);
return 0;
case NodeLeftHeavy:
setNodeHeavy(AvlNode, NodeBalance);
return -1;
case NoderightHeavy:
{
 treeNode *lt = AvlNode->r;
 if (NodeBalance == lt->NodeState)
 {
 AvlNode->r = lt->l;
 lt->l = AvlNode;
 setNodeHeavy(AvlNode, NoderightHeavy);
 setNodeHeavy(lt, NodeLeftHeavy);
 AvlNode = lt;
 return 0;
 }
 else if (NoderightHeavy == lt->NodeState)
 {
 AvlNode->r = lt->l;
 lt->l = AvlNode;
 setNodeHeavy(AvlNode, NodeBalance);
 setNodeHeavy(lt, NodeBalance);
 AvlNode = lt;
 return -1;
 }
 else// if (NoderightHeavy == lt->NodeState)
 {
 treeNode *rt = lt->l;
 AvlNode->r = rt->l;
 lt->l = rt->r;
 rt->l = AvlNode;
 rt->r = lt;
 if (NodeLeftHeavy == getNodeHeavy(rt))
 {
 setNodeHeavy(lt, NoderightHeavy);
 setNodeHeavy(AvlNode, NodeBalance);
 }
 else if (NoderightHeavy == getNodeHeavy(rt))
 {
 setNodeHeavy(lt, NodeBalance);
 setNodeHeavy(AvlNode, NodeLeftHeavy);
 }
 else if (NodeBalance == getNodeHeavy(rt))
 {
 setNodeHeavy(lt, NodeBalance);
 setNodeHeavy(AvlNode, NodeBalance);
 }
 setNodeHeavy(rt, NodeBalance);
 AvlNode = rt;
 return -1;//the node tree depth -1.
 }
}
default:
break;
}
}
}






int avlTreeManage::delOneNodeFromTree(treeNode *&AvlNode, NodeType Nid, int &findNodeFlag)
{
if (NULL == AvlNode)
{
return 0;
}
if (0 == findNodeFlag)
{
int cmpResolt = cmpAb(Nid, AvlNode->data);
if (0 == cmpResolt)
{
int delreturn;
findNodeFlag = 1;
if (NULL != SelectNode)
{
delete SelectNode;
SelectNode = NULL;
}
delreturn = delOneNodeFromTree(AvlNode->l, Nid, findNodeFlag);
if (NULL != SelectNode)
{
AvlNode->data = SelectNode->data;
delete SelectNode;
SelectNode = NULL;
}
else
{
SelectNode = AvlNode;
AvlNode = AvlNode->r;
delete SelectNode;
SelectNode = NULL;
return -1;
}
if (-1 == delreturn)
{
return adjustTreeNodeForDel(AvlNode, false);
}
else
{
return 0;
}
}
else if (cmpResolt < 0)
{
if (-1 == delOneNodeFromTree(AvlNode->l, Nid, findNodeFlag))
{
return adjustTreeNodeForDel(AvlNode, false);
}
else
{
return 0;
}
}
else
{
if (-1 == delOneNodeFromTree(AvlNode->r, Nid, findNodeFlag))
{
return adjustTreeNodeForDel(AvlNode, true);
}
else
{
return 0;
}
}


}
else if (1 == findNodeFlag)
{
if (NULL == AvlNode->r)
{
SelectNode = AvlNode;
AvlNode = AvlNode->l;
return -1;
}
else
{
if (-1 == delOneNodeFromTree(AvlNode->r, 0, findNodeFlag))
{
return adjustTreeNodeForDel(AvlNode, true);
}
else
return 0;
}
}


}
int avlTreeManage::liftDepth()
{
if (rootAvl == NULL)
{
return 0;
}
return Depth(rootAvl->l);
}
int avlTreeManage::rihgtDepth()
{
if (rootAvl == NULL)
{
return 0;
}
return Depth(rootAvl->r);
}
int avlTreeManage::Depth(treeNode *AvlNode)
{
if (NULL == AvlNode)
{
return 0;
}
int tempL;
int tempR;
tempL = Depth(AvlNode->l);
tempR = Depth(AvlNode->r);
if (tempL > tempR)
{
return tempL + 1;
}
else
{
return tempR + 1;
}
}


void avlTreeManage::delAvl()
{
delNode(rootAvl);
}


void avlTreeManage::delNode(treeNode *AvlNode)
{
if (NULL == AvlNode)
{
return;
}
delNode(AvlNode->l);
delNode(AvlNode->r);
delete AvlNode;
AvlNode = NULL;

}

////////////////////////avlAlgorithm.h

#define NodeBalance 0
#define NodeLeftHeavy 1
#define NoderightHeavy 2


typedef int NodeType;


typedef struct treeNode
{
treeNode *l;
treeNode *r;
NodeType data;
char NodeState;
treeNode(NodeType input = 0) :l(NULL), r(NULL), data(input), NodeState(0){};
};


class avlTreeManage
{
public:
avlTreeManage();
~avlTreeManage();
int findNode(NodeType Nid);
int addNode(NodeType Nid);
int delNode(NodeType Nid);
int liftDepth();
int rihgtDepth();
int getDepth();
void delAvl();
protected:
int find(treeNode *AvlNode, NodeType Nid);
int Depth(treeNode *AvlNode);
void delNode(treeNode *AvlNode);
int addNodeToTree(treeNode *&AvlNode, NodeType Nid);
int delOneNodeFromTree(treeNode *&AvlNode, NodeType Nid, int &findNodeFlag);
private:
treeNode *rootAvl;
};

///////////////////////////main.cpp

#include "stdafx.h"
#include "avlAlgorithm.h"
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include<iostream>
using namespace std;

//#define TREETOTALNUMBER 10000
int TREETOTALNUMBER;
int _tmain(int argc, _TCHAR* argv[])
{
avlTreeManage *useTree;
useTree = new avlTreeManage();
int i = 10;
int j;
int temp;
int leftd;
int rightd;
srand(time(0));
scanf_s("%d", &TREETOTALNUMBER);
//j = 1000;
//j = 0;
for (i = 0; i < TREETOTALNUMBER; i++)//for (i = TREETOTALNUMBER; i > 0; i--)
{
//j++;
//j--;
//j = rand();
temp = useTree->addNode(i);
leftd = useTree->liftDepth();
rightd = useTree->rihgtDepth();
printf("l=%d,r=%d\r\n", leftd, rightd);
}
printf("//////////////////////////////////////////////////////////////\r\n", leftd, rightd);
Sleep(1000);
for (i = 0; i < TREETOTALNUMBER; i++)
{
//j++;
//j--;
//j = rand();
temp = useTree->delNode(i);
leftd = useTree->liftDepth();
rightd = useTree->rihgtDepth();
printf("l=%d,r=%d\r\n", leftd, rightd);
}
delete useTree;
scanf_s("%d", &i);
return 0;
}