Print tree paths

最新推荐文章于 2021-09-14 19:50:14 发布

YMHH

最新推荐文章于 2021-09-14 19:50:14 发布

阅读量925

点赞数

分类专栏： Interviews 文章标签：递归遍历

本文链接：https://blog.csdn.net/ymhhym/article/details/21326879

版权

Interviews 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

Given a binary tree, print all the paths from root to leaves.

For example:
Given the below binary tree,

       1
      / \
     2   3

Print:

1 2

1 3

递归的方式很简单，如果要求非递归呢？可以从树的遍历考虑。因为需要保存路径，感觉后续遍历简单些，这样栈操作和树的路径操作可以对应起来 - 出栈的时候表明所有子节点已经访问过，这时可以把对应的路径也弹出。

递归，非递归代码如下，顺带了有递归方式的按层次遍历树，以前文章提到过，这个主要是为了降低层次遍历的空间复杂度。

// printTree.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <vector>
#include <stack>
using namespace std;

struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int value) {val = value; left = right = NULL;}
};

void printVector(vector<int> &v) {
	for (int i = 0; i < v.size(); ++i) {
		cout << v[i] << " ";
	}
	cout << endl;
}

void printPathsRecursive(TreeNode *root, vector<int> &path) {
	if (root == NULL) {
		return;
	}

	path.push_back(root->val);
	if (root->left == NULL && root->right == NULL) {
		printVector(path);
	}
	else {
		if (root->left != NULL) {
			printPathsRecursive(root->left, path);
		}
		if (root->right != NULL) {
			printPathsRecursive(root->right, path);
		}
	}
	path.pop_back();
}

void printPathsIterative(TreeNode *root) {
    if (root == NULL) {
        return;
    }
    
	TreeNode *prev = NULL;
    vector<int> path;
    stack<TreeNode*> nodes;
    while (root != NULL || !nodes.empty()) {
        while (root != NULL) {
            nodes.push(root);
            path.push_back(root->val);
            root = root->left;
        }
        if (!nodes.empty()) {
            root = nodes.top();
            if (root->right == NULL || root->right == prev) {
				if (root->left == NULL && root->right == NULL) {
					printVector(path);
				}
                nodes.pop();
				path.pop_back();
				prev = root;
                root = NULL;
            }
            else {
                root = root->right;
            }
        }
    }
}

void printLevel(TreeNode *root, int level) {
	if (root == NULL || level < 1) {
		return;
	}

	if (level == 1) {
		cout << root->val << " ";
		return;
	}

	printLevel(root->left, level - 1);
	printLevel(root->right, level - 1);
}

int getDepth(TreeNode *root) {
	if (root == NULL) {
		return 0;
	}

	int ldepth = getDepth(root->left);
	int rdepth = getDepth(root->right);
	return (max(ldepth, rdepth) + 1);
}

void printTreeByLevel(TreeNode *root) {
	int levels = getDepth(root);
	for (int i = 1; i <= levels; ++i) {
		printLevel(root, i);
		cout << endl;
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	TreeNode *root = new TreeNode(1);
	root->left = new TreeNode(2);
	root->left->left = new TreeNode(3);
	root->left->right = new TreeNode(5);
	root->right = new TreeNode(4);
	root->right->right = new TreeNode(6);
	root->right->right->left = new TreeNode(7);
	root->right->right->left->right = new TreeNode(9);
	root->right->right->right = new TreeNode(8);

	cout << "Print tree paths by iterative method: " << endl;
	printPathsIterative(root);

	cout << "Print tree paths by recursive method: " << endl;
	vector<int> path;
	printPathsRecursive(root, path);

	cout << "Print tree by level: " << endl;
	printTreeByLevel(root);

	return 0;
}