//删除树节点,到此时的树节点，最多只有一个孩子,而且是左孩子
void DeleteTreeNode(TreePtr tree,TreeNodePtr node)
{
TreeNodePtr brother = NULL;
TreeNodePtr child = NULL;
TreeNodePtr parent = NULL;
parent = node->parent;
child = (NULL == node->left) ? node->right : node->left;
//child = node->left;
//没有父节点和子女节点,是唯一一个节点,case 1
if ((NULL == child) && (NULL == parent))
{
SetRootNode(tree,NULL);
}
else if ((NULL != child) && (NULL == parent))
{
//只有一个孩子节点,没有父节点,case 2
SetRootNode(tree,child);
}
else if ((NULL == child) && (NULL != parent))
{
//没有孩子节点,有父节点
if (node == parent->left)
{
SetLeftChild(parent,NULL);//child = NULL
}
else
{
SetRightChild(parent,NULL);//child = NULL
}
/*
if (BlackNode == node->color)
{
DeleteNodeFix(tree,node);
}
*/
}
else
{
//有孩子节点,有父节点
if (node == parent->left)
{
SetLeftChild(parent,child);//child = NULL
}
else
{
SetRightChild(parent,child);//child = NULL
}
//N=B但是P=R,C=R时，需要将孩子节点设置为黑色
child->color = BlackNode;
if (BlackNode == node->color)
{
//这个节点已经代替了node的位置
DeleteNodeFix(tree,child);
}
}
FreeNode(tree,node);
}
//右旋转
void RightRotate(TreePtr tree,TreeNodePtr node)
{
//获取节点的父节点
TreeNodePtr parent = node->parent;
//变为自身左孩子的右孩子
//返回原来左孩子的右孩子（孙子）,自身左右孩子没变
TreeNodePtr right = SetRightChild(node->left,node);
//将左孩子作为父节点的右孩子,左孩子节点空出
//将右孩子作为父节点的(左,右)孩子,右孩子节点空出
if (NULL != parent)
{
if (parent->left == node)
{
SetLeftChild(parent,node->left);
}
else
{
SetRightChild(parent,node->left);
}
}
else
{
//表示是根节点,根节点没有父节点
SetRootNode(tree,node->left);
}
//将之前左孩子的右孩子设置为自身的左孩子
SetLeftChild(node,right);
}
//左旋转
void LeftRotate(TreePtr tree,TreeNodePtr node)
{
//获取节点的父节点
TreeNodePtr parent = node->parent;
//变为自身右孩子的左孩子
//返回原来右孩子的左孩子（孙子）,自身左右孩子没变
TreeNodePtr left = SetLeftChild(node->right,node);
//将右孩子作为父节点的(左,右)孩子,右孩子节点空出
if (NULL != parent)
{
if (parent->left == node)
{
SetLeftChild(parent,node->right);
}
else
{
SetRightChild(parent,node->right);
}
}
else
{
SetRootNode(tree,node->right);
}
//将之前右孩子的左孩子设置为右孩子
SetRightChild(node,left);
}
NodePosition InsertTreeNode(TreePtr tree,TreeNodePtr node)
{
NodePosition nodePosition = CoverNode;
Boolean ret = False;
TreeNodePtr parent = tree->root;
int compare = 0;
while(NULL != parent)
{
compare = Compare(parent->keyValue,node->keyValue,tree->keyType,tree->keyByteSize,tree->isSigned);
//遇到相同KEY的节点
if (compare == Compare_Equal)
{
//覆盖VALUE
memcpy(parent->keyValue + tree->keyByteSize,node->keyValue + tree->keyByteSize,tree->keyByteSize);
ret = True;
nodePosition = CoverNode;
break;
}
else if (compare == Compare_Less)
{
//父节点小于当前节点,则为父节点的右孩子
if (NULL == parent->right)
{
SetRightChild(parent,node);
ret = True;
nodePosition = RightNode;
break;
}
else
{
parent = parent->right;
}
}
else
{
//父节点大于当前节点,则为父节点的左孩子
if (NULL == parent->left)
{
SetLeftChild(parent,node);
ret = True;
nodePosition = LeftNode;
break;
}
else
{
parent = parent->left;
}
}
}
//一直到NULL都没有插入,那就是根节点了
if (False == ret)
{
//tree->root = node;
//node->color = BlackNode;
SetRootNode(tree,node);
nodePosition = RootNode;
}
return nodePosition;
}
NS_IMETHODIMP
inDOMView::Rebuild()
{
nsCOMPtr<nsIDOMNode> root;
GetRootNode(getter_AddRefs(root));
SetRootNode(root);
return NS_OK;
}
bool THISCLASS::Open(const wxFileName &filename) {
// Read the file
wxLogNull log;
mIsOpen = mDocument.Load(filename.GetFullPath());
if (! mIsOpen) {
mDocument.SetRoot(new wxXmlNode(0, wxXML_ELEMENT_NODE, wxT("swistrack")));
SelectRootNode();
return false;
}
// Select the root element and check its name
SetRootNode(mDocument.GetRoot());
if (GetRootNode()->GetName() != wxT("swistrack")) {
mIsOpen = false;
return false;
}
return true;
}
inDOMView::~inDOMView()
{
SetRootNode(nsnull);
}
void DecisionTree::SetRootNode(DecisionTreeNode* ip_root_node)
{
SetRootNode(ip_root_node->GetId());
}
static void CheckTree(TreePtr tree,TreeNodePtr node)
{
//父节点，祖父节点，叔父节点
TreeNodePtr parent,grand,uncle;//great
//与父节点的关系(左孩子还是右孩子),父节点与祖父节点的关系
NodePosition selfPosition,parentPosition;
parent = node->parent;
/*
great = (NULL != parent) ? parent->parent : NULL;
uncle = (NULL != great) ? ((great->left == parent) ? great->right : great->left) : NULL;
TreeColor selfColor = node->color;
TreeColor parentColor = (NULL != parent) ? parent->color : BlackNode;
TreeColor uncleColor = (NULL != uncle) ? uncle->color : BlackNode;
TreeColor greatColor = (NULL != great) ? great->color : BlackNode;
*/
//父节点为NULL，这表示是根节点
if (NULL == parent)
{
SetRootNode(tree,node);
}
else if ((node->color == RedNode) && (parent->color == RedNode))
{
//自身节点 父节点为红色
//这个时候一定会有一个祖父节点
grand = parent->parent;
uncle = (grand->left == parent) ? grand->right : grand->left;
//自身节点 父节点 叔父节点都为红色
if ((NULL != uncle) && (uncle->color == RedNode))
{
grand->color = RedNode;
parent->color = BlackNode;
uncle->color = BlackNode;
CheckTree(tree,grand);
//将祖父节点作为新插入的节点开始检测树的合法性
}
else //叔父节点是黑色或者空节点
{
//自身节点 父节点为红色 叔父节点为黑色（NULL表示黑色）
selfPosition = (node == parent->left) ? LeftNode : RightNode;
parentPosition = (parent == grand->left) ? LeftNode : RightNode;
//旋转分为 左左 左右 右左 右右
if ((selfPosition == LeftNode) && (parentPosition == LeftNode))
{
/*
G(b) P(b)
/ \ / \
P(r) U(b) --> N(r) G(r)
/ \ / \
N(r) M M U(b)
*/
RightRotate(tree,grand);
//左左的情况需要更换节点颜色,可以知道的是祖父节点肯定是黑色
parent->color = BlackNode;
grand->color = RedNode;
}
else if ((parentPosition == RightNode) && (selfPosition == LeftNode))
{
//右左
//以父节点右转，这个时候将变成右右的关系
RightRotate(tree,parent);
//要是减少递归，可以再转一次
//CheckTree(tree,node);
LeftRotate(tree,grand);
parent->color = BlackNode;
grand->color = RedNode;
}
else if ((parentPosition == LeftNode) && (selfPosition == RightNode))
{
//左右
//以父节点左转，这个时候将变成左左的关系
LeftRotate(tree,parent);
//下次检测则会发现是左左关系
//要是减少递归，可以再转一次
//CheckTree(tree,node);
RightRotate(tree,grand);
parent->color = BlackNode;
grand->color = RedNode;
}
else
{
//右右
/*
G(b) P(b)
/ \ / \
U(b) P(r) --> G(r) N(r)
/ \ / \
M N(r) U(b) M
*/
LeftRotate(tree,grand);
parent->color = BlackNode;
grand->color = RedNode;
}
}
//这里发现祖父节点肯定被染成了红色，而父节点都被染成黑色
//因为插入的是红色节点，而一个红节点必须包含两个黑色节点
//·
}
else
{
//这样表示调整基本完毕
}
}
