CareerCup

Hi,

Here is a simpler and most elegant implementation of the algorithm in Java.

public static int sumTheTree(BSTNode root) {		
		if (root == null) {
			return 0;
		}		
		root.data = root.data + sumTheTree(root.left) + sumTheTree(root.right);		
		return root.data;

}

- Vijay Muvva April 27, 2013 | Flag Reply

1                               28 
    2	     3	                   11	       16 
  4  5   6  7               4    5    6    7

node old value --- new value
1 -- 28
2 -- 11
3 -- 16
4 -- 4, 5 -- 5, 6 -- 6, 7 -- 7

- phaniteja.24 April 27, 2013 | Flag Reply

Traverse the tree in postorder and pass on the sums from child nodes to its parent.

Code:

public int getSumOfChildNodes(BinaryTree root) {
		if (root == null)
			return 0;
		int left = getSumOfChildNodes(root.left);
		int right = getSumOfChildNodes(root.right);
		int sum = left + right + root.data;
		System.out.println(root.data + " " + sum);
		return sum;
	}

- Dhass April 27, 2013 | Flag Reply

Do a post order traversal and node->data = node->data + node->left->data + node->right->data

int sumTreeNode(Tree * t)
{
if(!t)
return 0;

int leftsum = sumTreeNode(t->left);
int rightsum = sumTreeNode(t->right);

t->data = leftsum + rightsum;
return t->data;
}

- Anonymous April 27, 2013 | Flag Reply

void createSumTree(struct node *root){
     if(root==NULL || ( root->left==NULL && root->right==NULL)){
                   return;
     }
     else{
          int ls = 0;
          int rs = 0;
          createSumTree(root->left);
          createSumTree(root->right);
          if(root->left){
                 ls = root->left->data;
          }
          if(root->right){
                 rs = root->right->data;         
          }
          root->data = ls + rs + root->data;
     }
}

- Amit April 27, 2013 | Flag Reply

{{{ typedef struct bst { int data; bstptr left; bstptr right; }* bstptr; int treesum(bstptr b) { if(!b) return 0; return b.data + treesum(b->left) + treesum(b->right); } - lyf.pboy April 27, 2013 | Flag Reply

typedef struct bst {
	int data;
	bstptr left;
	bstptr right;
}* bstptr;
int treesum(bstptr b) {
	if(!b)
		return 0;
	return b.data + treesum(b->left) + treesum(b->right);
}

- lyf.pboy April 27, 2013 | Flag Reply

int CalculateSum_Node_ItsChildren(BinaryTree *T)
{
	int v,v1,v2;
	
	if(T == NULL)
	{
		return 0;
	}
	
	v1 = CalculateSum(T->leftChild);
	v2 = CalculateSum(T->rightChild);
	v = T->key + v1+v2;
	
	printf("%d --- %d\n", T->key, v);
	return v;
}

- KTN Varma April 28, 2013 | Flag Reply

public class TreeSumNodes {

    /**
     * @param args
     */
    public static void main(String[] args) {
        TreeNode head = new TreeNode(1);
        head.leftchild = new TreeNode(2);
        head.rightchild = new TreeNode(3);
        head.leftchild.leftchild = new TreeNode(4);
        head.leftchild.rightchild = new TreeNode(5);
        head.rightchild.leftchild = new TreeNode(6);
        head.rightchild.rightchild = new TreeNode(7);

        int sum = sumOfNodePlusChildNodes(head);
        System.out.println(sum);

    }

    private static int sumOfNodePlusChildNodes(TreeNode head) {
        if (head == null) {
            return 0;
        }
        return head.data + sumOfNodePlusChildNodes(head.leftchild) + sumOfNodePlusChildNodes(head.rightchild);
    }

    public static class TreeNode {

        TreeNode leftchild;

        TreeNode rightchild;

        int data;

        public TreeNode(int data) {
            this.data = data;
        }
    }

}

- rams April 28, 2013 | Flag Reply

public static int sumNodesBinaryTree(BTNode currNode) {
	if(currNode== null) return 0;
	else if(currNode.left == null and currNode.right == null)
		return currNode.value;
	else {
		leftChildSum = sumNodesBinaryTree(currNode.left);
		rightChildSum = sumNodesBinaryTree(currNode.right);
		currNode.value += leftChildSum  + rightChildSum ;
		return currNode.value ;
	}

}

- Subhajit April 29, 2013 | Flag Reply

Correct one:

typedef struct bst {
	int data;
	bstptr left;
	bstptr right;
}* bstptr;

int tree_sum_tree(bstptr b) {
	if(!b)
		return 0;
	b->data = b->data + tree_sum_tree(b->left) + tree_sum_tree(b->right);
	return b->data;
}

- lyf.pboy April 29, 2013 | Flag Reply