二叉查找树之——非递归实现

上一一篇文章介绍了二叉查找树的递归实现，递归算法以简洁明了，便于阅读与理解，但是只要是与递归有关，就少不了递归调用栈，也就是函数栈，这会导致栈溢出。假如递归层次达到10000次，程序就崩溃了，二叉查找树当插入的节点是升序或者逆序，就形成了链表，这样就形成了10000层递归。并且，递归没有非递归效率高，语音在于函数调用会相对耗时。所以非递归算法在安全性和效率上更实用。下面对二叉查找操作的非递归算法实现。

查找节点，很简单，通过循环来查找，代码如下：

Position CBinarySearchTreeNoRecursion::find( int iElement,const Root pRoot )
{
if ( NULL == pRoot )
{
return NULL;
}

TreeNode* pNode = pRoot;

while ( pNode != NULL )
{
if ( iElement < pNode->idata )
{
pNode = pNode->lchild;

}else if ( iElement > pNode->idata )
{
pNode = pNode->rchild;

}else
{
visit(pNode);
return pNode;   //找到则返回
}
}
return NULL;
}

查找最小元素，一直往左走，找到后访问，代码如下：

Position CBinarySearchTreeNoRecursion::findMin( const Root pRoot )
{
if ( NULL == pRoot )
{
return NULL;
}

TreeNode *pNode = pRoot;

while ( pNode->lchild != NULL) //一直走到最左边
{
pNode = pNode->lchild;
}

visit(pNode);
return pNode;
}

查找最大元素，一直往右走，找到后访问，代码如下：

Position CBinarySearchTreeNoRecursion::findMax( const Root pRoot )
{
if ( NULL == pRoot )
{
return NULL;
}

TreeNode *pNode = pRoot;

while ( pNode->rchild != NULL) //一直走到最右
{
pNode = pNode->rchild;
}

visit(pNode);
return pNode;
}

插入一个节点，就要找到位置后插入，因为找到后，遍历指针为NULL，就需要一个指针尾随着遍历指针，这样就可以插入后返回正确位置的指针，代码如下：

Root CBinarySearchTreeNoRecursion::insertNode( int iElement,Root pRoot )
{
if ( NULL == pRoot )
{
return NULL;
}

TreeNode* pNode = NULL;
TreeNode* pTemp = pRoot;

while ( pRoot != NULL )   //找到插入的位置
{
pNode = pRoot;//保存上一个节点的指针

if ( iElement < pRoot->idata )
{
pRoot = pRoot->lchild;

}else if (iElement > pRoot->idata )
{
pRoot = pRoot->rchild;

}else
{
pRoot->uiTimes++;
return pTemp;
}
}

if ( iElement < pNode->idata)   //插入该位置的左边还是右边
{
pNode->lchild = new TreeNode(iElement);

}else if (iElement > pNode->idata )
{
pNode->rchild = new TreeNode(iElement);
}

return pNode;
}

二叉树的非递归删除也是很复杂，首先，让我们用一个公用的删除策略，用删除的节点的右子树的最小节点代替被删除节点，这样就可以满足二叉树的定义：左小右大。删除时，又要看看特殊情况，如果删除的节点没有右孩子怎么处理？只有一个节点或者没有节点怎么处理？下面让我们来分情况讨论：

删除的节点有左右子树：选取右子树的最小值代替删除节点，然后删除最小节点。

删除的节点只有一个或着没有孩子：需要用一个指针跟踪要删除的节点的上一个节点位置，这样就可以删除节点后设置它的父亲节点左右子树正确的指针。

更多细节请看如下代码：

Root CBinarySearchTreeNoRecursion::deleteNode( int iElement,Root pRoot )
{
if ( NULL == pRoot )
{
return pRoot;
}

Root pNode       = pRoot;       //遍历用的指针
Root pLastNode   = pNode;       //遍历指针的上一个节点的指针
Root pMinOnRight = NULL;        //右子树最小节点的指针
Root pSecondMinOnRight = NULL;  //右子树次最小节点的指针

while ( pNode != NULL )
{
if ( iElement < pNode->idata )
{
pLastNode = pNode;
pNode     = pNode->lchild;
}else if ( iElement > pNode->idata )
{
pLastNode = pNode;
pNode     = pNode->rchild;
}else   //找到要删除的节点
{
if ( pNode->lchild != NULL && pNode->rchild != NULL )//有两个孩子情况
{
pSecondMinOnRight = pNode;
pMinOnRight       = pNode->rchild;

while ( pMinOnRight->lchild != NULL)      //删除策略：用右子树最小节点代替要删除的节点。找到最小的和次最小的节点
{
pSecondMinOnRight = pMinOnRight;
pMinOnRight       = pMinOnRight->lchild;
}

pNode->idata = pMinOnRight->idata;  //将找到的最小节点放到要删除的节点位置，其实是值交换

if ( NULL == pMinOnRight->rchild )  //找到的最小节点是叶子节点
{
pSecondMinOnRight->lchild = NULL;
}else                                 //找到的最小节点是非叶子节点，则要处理它的右孩子，将右孩子连接到最小节点的父亲节点处
{
pSecondMinOnRight->lchild = pMinOnRight->rchild;
}
printf("delete the  element: %d\n",pMinOnRight->idata);
delete pMinOnRight;
pMinOnRight = NULL;
return pRoot;

}else//一个或者零个孩子的情况
{
if ( pLastNode->lchild == pNode )     //要删除的节点是左子树还是右子树
{
if ( NULL == pNode->lchild )      //删除的节点是左节点
{
pLastNode->lchild = pNode->rchild;   //如果删除节点的左子树是空，则返回右子树
}else if ( NULL == pNode->rchild )
{
pLastNode->lchild = pNode->lchild;//如果删除节点的右子树是空，则返回左子树
}
}
else if( pLastNode->rchild == pNode )//删除的节点是右节点
{
if ( NULL == pNode->lchild )
{
pLastNode->rchild = pNode->rchild;
}else if ( NULL == pNode->rchild )
{
pLastNode->rchild = pNode->lchild;
}
}
printf("delete the  element: %d\n",pNode->idata);
delete pNode;
pNode = NULL;
return pRoot;
}
}
}

return pRoot;
}

下面来讲解遍历操作，遍历需要用到栈来保存将要被访问的节点指针，遍历有一个特点，就是中后遍历，只要遍历的左孩子，就是相当于遍历了左节点和跟节点，所以主要关注的是右子树。

前序遍历：根左右。先跟后左右子树，这个代码很好写，只需要将根节点入栈，然后出栈访问后再将其左右子树入栈，然后重复这个过程直到栈空，代码如下：

void CBinarySearchTreeNoRecursion::preOrder( const Root pRoot )
{
if ( NULL == pRoot )
{
return;
}

stack<TreeNode*> nodeStack;
nodeStack.push(pRoot);
TreeNode* pNode = pRoot;

while ( !nodeStack.empty() )
{
pNode = nodeStack.top();
nodeStack.pop();

visit(pNode);//访问根节点的逻辑

if ( pNode->rchild != NULL )
{
nodeStack.push(pNode->rchild);
}
if ( pNode->lchild != NULL )
{
nodeStack.push(pNode->lchild);
}
}
}

中序的遍历解放方案是：将一直往左找，找到最左边的节点后，访问该节点，然后出栈，将它的右子树入栈访问，重复这个过程。代码如下：

void CBinarySearchTreeNoRecursion::inOrder( const Root pRoot )
{
if ( NULL == pRoot )
{
return;
}

stack<TreeNode*> nodeStack;
TreeNode* pNode = pRoot;

while ( pNode || !nodeStack.empty() )
{
if ( pNode != NULL )
{
nodeStack.push(pNode);        //遍历左子树
pNode = pNode->lchild;

}else
{
pNode = nodeStack.top();
nodeStack.pop();
visit(pNode);//访问左节点的逻辑
pNode = pNode->rchild;   //遍历右子树
}
}
}

后序遍历比较复杂，因为不能单单通过入栈出栈来全部访问，必须设置一个标志，标志这个节点的右子树是否已经访问了，如果没有访问，则访问，否则将遍历右子树。

删除策略：首先将左边全部入栈，然后出栈访问，看看它的右子树是否已经访问，如果没有，则访问右子树否则访问它。必须用到一个辅助数据结构，这里用一个标志栈来与节点栈匹配，看对应的节点栈顶元素的右子树是否已经访问，false为未访问，true为已访问。

void CBinarySearchTreeNoRecursion::posOrder( const Root pRoot )
{
if ( NULL == pRoot )
{
return;
}

TreeNode* pNode = pRoot;
stack<TreeNode*> nodeStack;
stack<bool>      flageStack;  //标志栈，false：未访问，true:已访问

while ( pNode != NULL )       //将树的最左边节点全部入栈
{
nodeStack.push(pNode);
flageStack.push(false);   //这两个栈有同时出入，节点栈出栈，则标志栈也要出入。
pNode = pNode->lchild;
}

while ( !nodeStack.empty() )
{
pNode = nodeStack.top();
if (NULL == pNode->rchild || flageStack.top() )  //如果没有右子树或者右子树已经访问，则可以访问这个节点。
{
nodeStack.pop();
flageStack.pop();
visit(pNode);
}else        //右孩子存在并且这个节点没有被访问，则遍历右子树
{
flageStack.pop();
flageStack.push(true);   //因为下面将右子树入栈，右子树后肯定会先于它被访问
//所以这里可以设置这个节点的右孩子已经被访问。
pNode = pNode->rchild;
while ( pNode != NULL )  //遍历右子树
{
nodeStack.push(pNode);
flageStack.push(false);
pNode = pNode->lchild;
}
}
}
}