在二元树中找出和为某一值的所有路径

1. 题目

在二元树中找出和为某一值的所有路径
题目：输入一个整数和一棵二元树。
从树的根结点开始往下访问一直到叶结点所经过的所有结点形成一条路径。
打印出和与输入整数相等的所有路径。
例如 输入整数22和如下二元树
  10  
  / \  
  5 12  
  / \  
  4 7
则打印出两条路径：10, 12和10, 5, 7。

二元树节点的数据结构定义为：

struct BinaryTreeNode // a node in the binary tree
{
int m_nValue; // value of node
BinaryTreeNode *m_pLeft; // left child of node
BinaryTreeNode *m_pRight; // right child of node
};

 

2. 分析

      当访问到某一结点时，把该结点添加到路径上，并累加当前结点的值。如果当前结点为叶结点并且当前路径的和刚好等于输入的整数，则当前的路径符合要求，我们把它打印出来。如果当前结点不是叶结点，则继续访问它的子结点。当前结点访问结束后，递归函数将自动回到父结点。因此我们在函数退出之前要在路径上删除当前结点并减去当前结点的值，以确保返回父结点时路径刚好是根结点到父结点的路径。我们不难看出保存路径的数据结构实际上是一个栈结构，因为路径要与递归调用状态一致，而递归调用本质就是一个压栈和出栈的过程。

 

3. 参考代码

//.h

// 定义一个简单的栈结构
#define MAX_STACK_SIZE 100
class CStack
{
private:
 int m_Elements[MAX_STACK_SIZE];  // 所有可承载的栈元素
 int m_nCurrentSize;              // 当前栈的大小
public:
 CStack(void);
 ~CStack(void);

public:
 // 加入一个新的元素
 // 成功时返回true
 bool Push(int data);
 bool Pop(int &popData);

 // 此栈是否为空
 // 为空时返回true
 bool IsEmpty();

 // 清除栈里面的所有对象
 void Clear(){m_nCurrentSize = 0;};

 // 栈共有多少个元素
 int Count(){return m_nCurrentSize;};

 // 获取某指定元素
 int GetElement(int index);
};

struct BinaryTreeNode // a node in the binary tree
{
 int m_nValue; // value of node
 BinaryTreeNode *m_pLeft; // left child of node
 BinaryTreeNode *m_pRight; // right child of node
};

class CTreePathSum
{
public:
 CTreePathSum(void);
public:
 ~CTreePathSum(void);

public:
 void Test();

public:
 // 创建二叉树，添加相应的结点
 static void addBSTreeNode(BinaryTreeNode * & pCurrent, int value);

 // 销毁此树
 static void DestroyTree(BinaryTreeNode *& pNode);

private:
 void FindPath(BinaryTreeNode *pCurrent, int sum);
 bool IsLeaf(BinaryTreeNode *pCurrent);

private:
 int curr_path_sum;  // 计算时当前
 CStack m_stack;     // 保存当前路径的值
};

 

//.cpp

#include "StdAfx.h"
#include "TreePathSum.h"
#include <iostream>
using namespace std;

CStack::CStack(void)
{
 m_nCurrentSize = 0;    // 将当前大小置0
}

CStack::~CStack(void)
{
}

// 加入一个新的元素
// 成功时返回true
bool CStack::Push(int data)
{
 // 此时栈已经满了
 if(m_nCurrentSize >= MAX_STACK_SIZE)
  return false;

 m_Elements[m_nCurrentSize] = data;
 m_nCurrentSize++;
 return true;
}

bool CStack::Pop(int &popData)
{
 if(IsEmpty())
  return false;
 
 m_nCurrentSize--;
 popData = m_Elements[m_nCurrentSize];
 return true;
}

// 此栈是否为空
// 为空时返回true
bool CStack::IsEmpty()
{
 return (m_nCurrentSize <= 0);
}

int CStack::GetElement(int index)
{
 if(index >= 0 && index < m_nCurrentSize)
  return m_Elements[index];

 return -1;
}

CTreePathSum::CTreePathSum(void)
{
 int curr_path_sum = 0;
}

CTreePathSum::~CTreePathSum(void)
{
}

void CTreePathSum::addBSTreeNode(BinaryTreeNode * & pCurrent, int value)
{
    if (NULL == pCurrent)
    {
        BinaryTreeNode * pBSTree = new BinaryTreeNode();
        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
        {
            //cout<<"重复加入节点"<<endl;
        }
    }
}

// 销毁此树
void CTreePathSum::DestroyTree(BinaryTreeNode *& pNode)
{
 if(pNode == NULL)
  return;

 DestroyTree(pNode->m_pLeft);
 DestroyTree(pNode->m_pRight);

 if(pNode->m_pLeft == NULL && pNode->m_pRight == NULL)
 {
  delete pNode;
  pNode = NULL;
 }

}

bool CTreePathSum::IsLeaf(BinaryTreeNode *pCurrent)
{
 return (pCurrent->m_pLeft == NULL && pCurrent->m_pRight==NULL);
}

void CTreePathSum::FindPath(BinaryTreeNode *pCurrent, int sum)
{
 if(pCurrent == NULL)
  return;

 curr_path_sum += pCurrent->m_nValue;

 m_stack.Push(pCurrent->m_nValue);         //压入当前节点值
 if(curr_path_sum == sum && IsLeaf(pCurrent))   // 找到了
 {
  for(int i=0; i<m_stack.Count(); i++)
  {
   std::cout<<m_stack.GetElement(i)<<" ";
  }
  cout<<endl;
  int n=0;
  n++;
 }

 if(pCurrent->m_pLeft != NULL)
  FindPath(pCurrent->m_pLeft, sum);

 if(pCurrent->m_pRight != NULL)
  FindPath(pCurrent->m_pRight, sum);

 curr_path_sum -= pCurrent->m_nValue;

 int ntemp = 0;
 m_stack.Pop(ntemp);
}

void CTreePathSum::Test()
{
 curr_path_sum = 0;
 m_stack.Clear();

 // 构造相应的二叉树
 BinaryTreeNode *pRoot = NULL;
 addBSTreeNode(pRoot, 10);
 addBSTreeNode(pRoot, 5);
 addBSTreeNode(pRoot, 12);
 addBSTreeNode(pRoot, 4);
 addBSTreeNode(pRoot, 7);

 // 找到符合条件的路径
 int ncur = 0;
 FindPath(pRoot, 22);

 DestroyTree(pRoot);
}