﻿ Print all paths in a binary tree ~ Programming Tutorials by SourceTricks
Friday, July 13, 2012

## Print all paths in a binary tree

### Write a program to print all paths in a binary tree starting from the root

The approach:-
1. Initialize an array with size as maximum depth of the tree.

2. Fill the node details in this array as we traverse the tree.

3. If leaf node is reached a path is traversed and print the path.

4. Recursively scan the left and right sub tree.

#### C++ program to print all paths in a binary tree starting from the root

```#include <iostream>
#include <cstdlib>
using namespace std;

// Node class
class Node {
public:
Node() { mData = -1; mParent = NULL; mLeft = NULL; mRight = NULL; }
~Node() {}
int data() { return mData; }
void setData(int data) { mData = data; }
Node* left() { return mLeft; }
void setLeft(Node* left) { mLeft = left; }
Node* right() { return mRight; }
void setRight(Node* right) { mRight = right; }
Node* parent() { return mParent; }
void setParent(Node* parent) { mParent = parent; }
private:
int mData;
Node* mLeft;
Node* mRight;
Node* mParent;
};

// Tree class
class Tree {
public:
Tree() { mRoot = NULL; }
~Tree() {}
Node* root() { return mRoot; }
int maxdepth(Node *node);
int mindepth(Node *node);
void print_all_paths(Node* node, int* path, int len);

private:
void print_array(int* path, int len);

private:
Node* mRoot;
};

if ( mRoot == NULL ) {
Node* tmp = new Node();
tmp->setData(data);
mRoot = tmp;
}
else {
}
}

void Tree::addNode(Node* node, int data) {
if ( data <= node->data() ) {
if ( node->left() != NULL )
else {
Node* tmp = new Node();
tmp->setData(data);
tmp->setParent(node);
node->setLeft(tmp);
}
}
else {
if ( node->right() != NULL )
else {
Node* tmp = new Node();
tmp->setData(data);
tmp->setParent(node);
node->setRight(tmp);
}
}
}

int Tree::maxdepth(Node *node) {
if ( node )
return 1 + std::max(maxdepth(node->left()),
maxdepth(node->right()));
else
return 0;
}

int Tree::mindepth(Node *node) {
if ( node )
return 1 + std::min(mindepth(node->left()),
mindepth(node->right()));
else
return 0;
}

void Tree::print_all_paths(Node* node, int* path, int len) {
if ( node == NULL )
return;

path[len] = node->data();
len++;

if ( node->left() == NULL && node->right() == NULL ) {
// leaf node is reached
print_array(path, len);
return;
}

print_all_paths(node->left(), path, len);
print_all_paths(node->right(), path, len);
}

void Tree::print_array(int* path, int len) {
for ( int i = 0; i < len; i++ )
cout << path[i] << " ";
cout << endl;
}

int main() {
Tree* t = new Tree();

int d = t->maxdepth(t->root());
int* path = (int*) malloc(sizeof(int) * d);
int len = 0;
t->print_all_paths(t->root(), path, len);

delete path;
delete t;
}```

Output:-
```500 300 200 150
500 300 200 250
500 300 350
500 600 550
500 600 700 750 800```

Name

Email *

Message *