打印二叉查找树中与输入整数相等的所有路径

输入一个整数和一棵二元树。
从树的根结点开始往下访问一直到叶结点所经过的所有结点形成一条路径。

打印出和与输入整数相等的所有路径。

思路：

建立一个由双向链表组成的栈，之所以用栈是因为递归，之所以用双向链表是为了可以顺序打印路径。

然后在二叉查找树中递归寻找路径。

代码如下：

#include<stdio.h>
#include<stdlib.h>

//二叉查找树数据结构
struct BSTreeNode;


struct BSTreeNode
{
int m_nValue;
BSTreeNode *m_pLeft;
BSTreeNode *m_pRight;
};



//双向链表栈数据结构
struct Node;
typedef Node* Link;
struct Node
{
int data;
Link next;
Link pre;
};
struct Stack
{
Link pHead;//头节点
Link pEnd;//尾节点
};

//创建二叉查找树
void addBSTreeNode(BSTreeNode *&pCurrent,int value)
{
if(NULL==pCurrent)
{
BSTreeNode *pBSTree=new BSTreeNode();
pBSTree->m_pLeft=NULL;
pBSTree->m_pRight=NULL;
pBSTree->m_nValue=value;
pCurrent=pBSTree;
}
else
{
       if((pCurrent->m_nValue)>value)
  addBSTreeNode(pCurrent->m_pLeft,value);
  else if((pCurrent->m_nValue)<value)
  addBSTreeNode(pCurrent->m_pRight,value);
  else
  return;
}
}

void Push(Stack &S,int element)
{
if(S.pHead==NULL)
{
S.pHead=(Link)malloc(sizeof(Node));
S.pEnd=(Link)malloc(sizeof(Node));
if(S.pEnd==NULL || S.pHead==NULL)
{
printf("out of space\n");
return;
}
S.pHead->data=element;
S.pHead->next=NULL;
S.pHead->pre=NULL;
S.pEnd=S.pHead;
}
else
{
Link NewNode;
NewNode=(Link)malloc(sizeof(Node));
if(NewNode==NULL)
{
printf("out of space\n");
return;
}
NewNode->data=element;
NewNode->next=S.pHead;
S.pHead->pre=NewNode;
NewNode->pre=NULL;
S.pHead=NewNode;
}
}
int IsEmpty(Stack S)
{
if(S.pHead!=NULL)
return 0;
else
return 1;
}


void Pop(Stack &S)
{//注意最后一个节点删除时需特殊考虑
Link temp;
if(!IsEmpty(S))
{
if(S.pHead==S.pEnd)
{
temp=S.pHead;
S.pHead=NULL;
S.pEnd=NULL;
free(temp);
}
else
{
   temp=S.pHead;
   S.pHead=S.pHead->next;
   S.pHead->pre=NULL;
   free(temp);
}
}
}
void Print_Stack(Stack S)
{//从尾节点开始打印栈的内容
Link temp=S.pEnd;
while(temp)
{
printf("%6d",temp->data);
temp=temp->pre;
}
}


void Find_Path(BSTreeNode* T,Stack &S,int num)
{
if(T->m_nValue==num)
{
Print_Stack(S);
printf("%6d\n",T->m_nValue);
}
else if(num-T->m_nValue<T->m_nValue)//该条件下只能从左子树中查找
{
if(T->m_pLeft)
{
Push(S,T->m_nValue);
Find_Path(T->m_pLeft,S,num-T->m_nValue);
Pop(S);
}
else return;
}
else if(num-T->m_nValue>T->m_nValue)//左右子树分别进行查找
{
if(T->m_pLeft)
{
Push(S,T->m_nValue);
Find_Path(T->m_pLeft,S,num-T->m_nValue);
Pop(S);
}
if(T->m_pRight)
{
Push(S,T->m_nValue);
Find_Path(T->m_pRight,S,num-T->m_nValue);
Pop(S);
   }
}
}

int main()
{
BSTreeNode *pRoot=NULL;
Stack S;
S.pEnd=NULL;
S.pHead=NULL;



addBSTreeNode(pRoot,10);
addBSTreeNode(pRoot,6);
addBSTreeNode(pRoot,8);
addBSTreeNode(pRoot,9);
addBSTreeNode(pRoot,7);
addBSTreeNode(pRoot,11);
addBSTreeNode(pRoot,12);
Find_Path(pRoot,S,33);
}

输出：

    10     6     8     9
    10    11    12
请按任意键继续. . .