error in traversal of all of path in binary tree

[fila]

Hi all;
The matrix paths[i][j] determine the path index i meeting the node number j.
I have written the following code for traversing all of the paths in a binary tree. There is no problem in debugging but as trace line by line, there is a problem in running the code which "counterpath" is not increased it is remain 0. Therefore the matrix Paths is overwritten in rows. The path number 1,2, ... is written in path number 0 when they are founded.
Would you please give me some guidance that what is the problem of my code?

tree nodes rows are nodes and columns are: 0:leaf/split node, 1: left node, 2&3 are not important now, 4: right node
for instance TREENODES[21][0]=1 means that this is leaf node, TREENODES[21][1]=40 means than the left child of 21 is 40, TREENODES[21][4]=45 means than the right child of 21 is 45.
I want to find all of the paths from this arrays and save them in a matrix named Paths. Each row of it determines a path and each column of it determine the meeting node of path. For instance Paths[2]={0,1,5,11,27,50,94} means that for the third leaf from the left (node:94) there is a path traversing the node numbers 0,1,5,11,27,50,94

All of variable such as counterpath,counterelempath, Paths,.. are global variables

void findpath(int node, int counterpath, int counterelempath)
{
if(numvisitedleaves==numofleaves)
return;
Paths[counterpath][counterelempath]=node;

if((TREENODES[node][4]==MAXNUMINFI) && (TREENODES[node][1]==MAXNUMINFI))
{
addpath(counterelempath);
++counterpath;// one path=one leaf is found go to next leaf=path
++numvisitedleaves;
}
else
{
++counterelempath;
findpath(TREENODES[node][1],counterpath,counterelempath);
findpath(TREENODES[node][4],counterpath,counterelempath);
}
}

void main()
{
counterpath=0;
node=0;
counterelempath=0;
numvisitedleaves=0;
while(numvisitedleaves!=numofleaves)
findpath(node,counterpath,counterelempath); // find all paths from this node. At first this node is root=0 and index of it is 0
}

[ne555]

Your code is incomplete. We can not compile and run it.

I don't understand what you are trying to do. ¿What's the purpose of the `Paths' matrix? If you want the path to the root, an array would suffice.

You are using global variables instead of simply arguments to the function. That makes the code hard to follow and error prone (especially considering that you are using recursion)

`node' is supposed to represent the current node that you are working on. However, if it has a left child you change it in node=TREENODES[counterelempath][1];. And later in `findpath()'.
So later, when you test if it has a right child, you lost any reference to the "current" node.

[fila]

Hi
I have edited the sending version in above. My problem is reset of "counterpath" in every calling of function "findpath". I do not how I can solve this as I want the global amount of "counterpath". For counterelempath there is no problem because I want to reset it in every calling!
TREENODES [NUMNODE][5] = {
/*0*/ {0, 1, 35, 0, 2},
/*1*/ {0, 5, 0, 1, 6},
/*2*/ {0, 3, 0, 2, 4},
/*3*/ {0, 13, 16, 3, 14},
/*4*/ {0, 7, 1, 4, 8},
/*5 */{0, 11, 1, 5, 12},
/*6 */{0, 9, 16, 6, 10},
/*7 */{0, 15, 48, 7, 16},
/*8 */{0, 21, 16, 8 , 22},
/*9*/ {0 , 19 , 1 , 9, 20},
/*10*/ {0 , 23 , 1 , 10, 24},
/*11*/ { 0 ,27 , 16 , 11 , 28},
/*12 */ {0, 25 , 37 , 12 , 26},
/*13*/ {0 ,17 , 1 , 13 , 18},
/*14*/ {0, 33 , 37 , 14, 34},
/*15*/ {0, 37 , 16 , 15 , 38},
/*16 */ {0, 31 , 16 , 16 , 32},
/*17 */ {0, 53 , 48 , 17, 54},
/*18 */ {0, 43 , 26 , 18 , 44},
/*19 */ {0 ,47 , 26 , 19 , 48},
/*20*/ {0, 39, 7 , 20, 40},
/*21*/ {0 ,41 ,26 , 21 , 42},
/*22*/ {0 ,35, 37 , 22, 36},
/*23*/ {0, 55, 48, 23, 56},
/*24*/ {0 , 29 , 37, 24, 30},
/*25*/ { 0, 75 , 48 , 25, 76},
/*26*/ { 0 ,45 , 26 , 26, 46},
/*27*/ { 0 ,49, 26 , 27, 50},
/*28*/ { 0 ,63 , 22 , 28, 64},
/*29*/ {0, 61 , 26 , 29 , 62},
/*30*/ {0 ,77 , 22 , 30, 78},
/*31*/ { 0, 79 , 37 , 31 , 80},
/*32*/ { 0 ,51 , 26 , 32 , 52},
/*33*/ { 0, 69 , 48 , 33 , 70},
/*34*/ { 0 ,71 , 26 , 34, 72},
/*35*/ { 0, 65 , 26 , 35 , 66},
/*36*/ { 0, 67 , 48 , 36 , 68},
/*37*/ { 0 ,57 , 22 , 37, 58},
/*38*/ { 1, MAXNUMINFI, MAXNUMINFI, 38, MAXNUMINFI },
/*39*/ { 0, 85, 48 , 39, 86},
/*40*/{ 1, MAXNUMINFI, MAXNUMINFI, 40, MAXNUMINFI},
/*41*/{ 0, 73 , 22 , 41 , 74},
/*42*/{ 1, MAXNUMINFI, MAXNUMINFI, 42 , MAXNUMINFI },
/*43*/ {1, MAXNUMINFI , MAXNUMINFI, 43, MAXNUMINFI },
/*44 */{ 0 ,83 , 37 , 44, 84},
/*45*/{ 1, MAXNUMINFI , MAXNUMINFI ,45 , MAXNUMINFI },
/*46*/ { 0, 59 , 48 , 46 , 60},
/*47*/ { 0, 89 , 7 , 47 , 90},
/*48*/{ 0, 97 , 44 , 48, 98},
/*49*/{ 1, MAXNUMINFI, MAXNUMINFI, 49 , MAXNUMINFI},
/*50*/ { 0 ,93, 22 , 50, 94},
/*51*/ {1, MAXNUMINFI, MAXNUMINFI, 51 , MAXNUMINFI },
/*52*/{ 1, MAXNUMINFI , MAXNUMINFI ,52, MAXNUMINFI },
/*53*/{ 1, MAXNUMINFI, MAXNUMINFI, 53 , MAXNUMINFI },
/*54*/{0 , 81 , 26 , 54, 82},
/*55*/ {0, 87, 22 , 55, 88},
/*56*/{1, MAXNUMINFI, MAXNUMINFI, 56, MAXNUMINFI },
/*57*/ {1, MAXNUMINFI , MAXNUMINFI, 57 , MAXNUMINFI },
/*58*/ {1 , MAXNUMINFI, MAXNUMINFI ,58 , MAXNUMINFI },
/*59*/{ 1 , MAXNUMINFI , MAXNUMINFI, 59 , MAXNUMINFI },
/*60*/{ 1 , MAXNUMINFI, MAXNUMINFI ,60, MAXNUMINFI },
/*61*/{ 1, MAXNUMINFI, MAXNUMINFI ,61, MAXNUMINFI },
/*62*/{ 1, MAXNUMINFI, MAXNUMINFI, 62, MAXNUMINFI },
/*63*/{ 1, MAXNUMINFI, MAXNUMINFI ,63, MAXNUMINFI },
/*64*/ {0 , 91 , 4 , 64, 92},
/* 65*/{ 1, MAXNUMINFI, MAXNUMINFI, 65 , MAXNUMINFI },
/* 66*/{ 1 , MAXNUMINFI , MAXNUMINFI ,66, MAXNUMINFI },
/* 67*/{ 1 , MAXNUMINFI , MAXNUMINFI ,67 , MAXNUMINFI },
/* 68*/{ 1, MAXNUMINFI , MAXNUMINFI ,68, MAXNUMINFI },
/*69*/ {1 , MAXNUMINFI, MAXNUMINFI, 69, MAXNUMINFI },
/*70*/ {1 , MAXNUMINFI, MAXNUMINFI ,70, MAXNUMINFI },
/*71*/ {1 , MAXNUMINFI, MAXNUMINFI ,71, MAXNUMINFI },
/*72*/{ 1 , MAXNUMINFI , MAXNUMINFI, 72 , MAXNUMINFI },
/*73*/ {1 , MAXNUMINFI, MAXNUMINFI, 73, MAXNUMINFI },
/*74*/ {1 , MAXNUMINFI , MAXNUMINFI, 74, MAXNUMINFI },
/*75*/ { 0, 95 , 16 , 75 , 96},
/*76*/ {1, MAXNUMINFI , MAXNUMINFI, 76 , MAXNUMINFI },
/*77*/{ 1, MAXNUMINFI, MAXNUMINFI ,77, MAXNUMINFI },
/*78*/ {1 , MAXNUMINFI , MAXNUMINFI , 78, MAXNUMINFI },
/*79*/ {1, MAXNUMINFI , MAXNUMINFI ,79 , MAXNUMINFI },
/*80*/{ 1, MAXNUMINFI , MAXNUMINFI, 80 , MAXNUMINFI },
/*81*/{ 1 , MAXNUMINFI , MAXNUMINFI ,81, MAXNUMINFI },
/*82*/{ 1 , MAXNUMINFI, MAXNUMINFI, 82 , MAXNUMINFI },
/*83*/ {1 , MAXNUMINFI, MAXNUMINFI, 83 , MAXNUMINFI },
/*84*/{ 1 , MAXNUMINFI , MAXNUMINFI, 84 , MAXNUMINFI },
/*85*/ {1 , MAXNUMINFI , MAXNUMINFI, 85, MAXNUMINFI },
/*86*/ {1 , MAXNUMINFI, MAXNUMINFI ,86, MAXNUMINFI },
/*87*/ {1, MAXNUMINFI , MAXNUMINFI ,87, MAXNUMINFI },
/*88*/{1 , MAXNUMINFI , MAXNUMINFI, 88, MAXNUMINFI },
/*89*/ {1 , MAXNUMINFI , MAXNUMINFI ,89, MAXNUMINFI },
/*90*/ {1 , MAXNUMINFI, MAXNUMINFI, 90, MAXNUMINFI },
/*91*/ {1 , MAXNUMINFI , MAXNUMINFI ,91, MAXNUMINFI },
/*92*/ {1, MAXNUMINFI, MAXNUMINFI, 92, MAXNUMINFI },
/*93*/ {1, MAXNUMINFI, MAXNUMINFI, 93 , MAXNUMINFI },
/*94*/{ 1 , MAXNUMINFI , MAXNUMINFI, 94 , MAXNUMINFI },
/*95*/ {1 , MAXNUMINFI, MAXNUMINFI, 95, MAXNUMINFI },
/*96*/{ 1, MAXNUMINFI , MAXNUMINFI ,96, MAXNUMINFI },
/*97*/{ 1 , MAXNUMINFI, MAXNUMINFI, 97, MAXNUMINFI },
/*98*/{ 1 , MAXNUMINFI , MAXNUMINFI ,98, MAXNUMINFI }};
int counterpath;
int counterelempath;


void findpath(int node, int counterpath, int counterelempath)
{
if(numvisitedleaves==numofleaves)
return;
Paths[counterpath][counterelempath]=node;

if((TREENODES[node][0]==MAXNUMINFI) && (TREENODES[node][1]==MAXNUMINFI))
{

++counterpath;// one path=one leaf is found go to next leaf=path
++numvisitedleaves;
}
else
{
++counterelempath;
findpath(TREENODES[node][1], int counterpath, int counterelempath);
findpath(TREENODES[node][4], int counterpath, int counterelempath);
}
}

void main()
{
counterpath=0;
counterelempath=0;
node=0;
findpath(0,0,0);
}