求二叉树从根节点到每个叶子节点路径上不重复数字的最大个数

问题

这个题我在做一个测试的时候做的，当时我忘记保存题目了，只是记着题目大意：求二叉树从根节点到每个叶子节点路径上不重复数字的最大个数。举个例子，如下二叉树：

从根节点到叶子节点的路径总过有三条：（1,3,4,1）；（1,4,2）；（1,4,4）。对应的不重复数字个数为：3,3,2；那么就需要程序返回3。

解法

由于需要二叉树，我们先给出构造二叉树的代码。在初始化二叉树的时候，根据给定向量使用宽度优先遍历的方式构造。上图二叉树的构造向量为[1,3,4,4,0,2,4,1]，当节点空的时候用零表示，向量中每个元素都是自然数，即都大于等于零。

//tree.h
#pragma once  
#include <iostream>  
#include <vector>  
#include <queue>  
using namespace std;

//定义二叉树节点类型  
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

//初始化一个二叉树  
TreeNode* initBTree(vector<int> elements);

//树的前序遍历  
void preOrder(TreeNode *root, vector<int> &result);
//树的中序遍历  
void inOrder(TreeNode *root, vector<int> &result);
//树的后序遍历  
void postOrder(TreeNode *root, vector<int> &result);
//vector的遍历  
void traverse(vector<int> nums);

下面是实现细节：

//tree.cpp

#include "tree.h"  

TreeNode* initBTree(vector<int> elements)
{
    int size = elements.size();
    if (size < 1)
    {
        return NULL;
    }
    //动态申请size大小的指针数组  
    TreeNode **nodes = new TreeNode*[size];
    //将int数据转换为TreeNode节点  
    for (int i = 0; i < size; i++)
    {
        if (elements[i] == 0)
        {
            nodes[i] = NULL;
        }
        else
        {
            nodes[i] = new TreeNode(elements[i]);
        }
    }
    queue<TreeNode*> nodeQueue;
    nodeQueue.push(nodes[0]);

    TreeNode *node;
    int index = 1;
    while (index < size)
    {
        node = nodeQueue.front();
        nodeQueue.pop();

        if (node == NULL)
        {
            continue;
        }

        nodeQueue.push(nodes[index++]);
        node->left = nodeQueue.back();

        if (index == size)
        {
            node->right = NULL;
            break;
        }
        nodeQueue.push(nodes[index++]);
        node->right = nodeQueue.back();
    }
    return nodes[0];
}

void preOrder(TreeNode *root, vector<int> &result)
{
    if (root)
    {
        result.push_back(root->val);
        preOrder(root->left, result);
        preOrder(root->right, result);
    }
}

void inOrder(TreeNode *root, vector<int> &result)
{
    if (root)
    {
        inOrder(root->left, result);
        result.push_back(root->val);
        inOrder(root->right, result);
    }
}

void postOrder(TreeNode *root, vector<int> &result)
{
    if (root)
    {
        postOrder(root->left, result);
        postOrder(root->right, result);
        result.push_back(root->val);
    }
}

void traverse(vector<int> nums)
{
    vector<int>::size_type size = nums.size();
    for (size_t i = 0; i < size; i++)
    {
        cout << nums[i] << ' ';
    }
    cout << endl;
}

在有了二叉树之后我们就可以进行下面的工作了。解决这个问题，除了遍历二叉树之外还有一个问题需要解决。给定一个数组，如何求出这个数组中不重复数字的个数。我先想了一个比较的笨的方法：使用两层循环让数组元素一一比较，并且将相同情况标记，然后在遍历一次数组根据标记的情况得出不重复的个数。具体如代码：

/**
 * 求一个向量中元素不重复出现的个数；如{1,2,1,3,2,2}，需要返回3；
 */
int cumputeNoRepeat(vector<int> vector)
{
    int res = 0;
    for (int i = 0; i < vector.size() - 1; ++i)
    {
        if (vector[i] == -1) continue;              //已经处理过的数字不再处理
        for (int j = i + 1; j < vector.size(); ++j)
        {
            if (vector[j] == -1 ) continue;         //已经处理过的数字不再处理
            if (vector[i] == vector[j])
            {
                vector[j] = -1;
            }
        }
    }
    for (int i = 0; i < vector.size(); ++i)
    {
        if (vector[i] != -1)      //求没有被置为-1的个数，就是不重复的个数
        {
            res++;
        }
    }

    return res;
}

我们想得到二叉树一条从根节点到叶子节点的路径上的所有节点，二叉树的先序遍历是比较合适的选择。跟随二叉树遍历，调整记录的数据，然后使用上面的函数求解不重复的个数，最后保留最大的并返回。

/*
 * 求一个二叉树中从根节点到叶子节点的路径上不重复数字的个数
 */
int solution(TreeNode *T)
{
    stack<TreeNode*> s;
    vector<int> v;
    TreeNode *p = T;
    int res = 0;
    int temp = 0;

    while (p != NULL || !s.empty())
    {
        while (p != NULL)
        {
            v.push_back(p->val);
            s.push(p);
            p = p->left;
        }

        temp = cumputeNoRepeat(v);
        if (temp > res)
        {
            res = temp;
        }

        if (!s.empty())
        {
            p = s.top();
            s.pop();
            p = p->right;

            v.pop_back();
        }
    }

    return res;
}

最后给出整体的测试代码：

//main.cpp

#include <stack>
#include "tree.h"

/**
 * 求一个向量中元素不重复出现的个数；如{1,2,1,3,2,2}，需要返回3；
 */
int cumputeNoRepeat(vector<int> vector)
{
    int res = 0;
    for (int i = 0; i < vector.size() - 1; ++i)
    {
        if (vector[i] == -1) continue;              //已经处理过的数字不再处理
        for (int j = i + 1; j < vector.size(); ++j)
        {
            if (vector[j] == -1 ) continue;         //已经处理过的数字不再处理
            if (vector[i] == vector[j])
            {
                vector[j] = -1;
            }
        }
    }
    for (int i = 0; i < vector.size(); ++i)
    {
        if (vector[i] != -1)      //求没有被置为-1的个数，就是不重复的个数
        {
            res++;
        }
    }

    return res;
}

/*
 * 求一个二叉树中从根节点到叶子节点的路径上不重复数字的个数
 */
int solution(TreeNode *T)
{
    stack<TreeNode*> s;
    vector<int> v;
    TreeNode *p = T;
    int res = 0;
    int temp = 0;

    while (p != NULL || !s.empty())
    {
        while (p != NULL)
        {
            //cout << p->val << " ";
            v.push_back(p->val);
            s.push(p);
            p = p->left;
        }

        temp = cumputeNoRepeat(v);
        if (temp > res)
        {
            res = temp;
        }

        if (!s.empty())
        {
            p = s.top();
            s.pop();
            p = p->right;

            v.pop_back();
        }
    }

    return res;
}

int main()
{
    vector<int> nums{1,2,3,4,0,1,6,2,0,1,3,0,6};
    TreeNode *root = initBTree(nums);
    vector<int> preResult;
    vector<int> inResult;
    vector<int> postResult;
    preOrder(root, preResult);
    inOrder(root, inResult);
    postOrder(root, postResult);
    cout << "前序遍历的结果：" << '\n';
    traverse(preResult);
    cout << "中序遍历的结果：" << '\n';
    traverse(inResult);
    cout << "后序遍历的结果：" << '\n';
    traverse(postResult);

    cout << "test cumputeNoRepeat ";
    vector<int> cnr{ 1, 1, 2, 3, 4, 3, 1, 5, 2 };
    cout << "num = " << cumputeNoRepeat(cnr) << endl;

    cout << "test solution ";
    cout << "max = " << solution(root) << endl;

    return 0;
}

你可以根据

vector<int> nums{1,2,3,4,0,1,6,2,0,1,3,0,6}

以先序遍历遇到零为空的方式，恢复出二叉树，判断测试结果是否正确。

参考

http://blog.csdn.net/theonegis/article/details/44223247