C++ (Cpp) hasPathSum示例

示例#1

文件： treeproblems.c 项目： karthik-mallavarapu/Stanford-Tree-problems

int hasPathSum(struct node* n, int sum) {

int stemp=0;
if(n != NULL) {
  sum = sum - n->data;
  if(n->left != NULL || n->right != NULL) {
    if(n->right == NULL) {
     if(hasPathSum(n->left,sum) == 1) 
       return 1;
     }
    else if(n->left == NULL) {
     if(hasPathSum(n->right,sum) == 1)
      return 1;
    }
    else {
      if(hasPathSum(n->left,sum) == 1)
        return 1;
      if(hasPathSum(n->right,sum) == 1)
        return 1;

    }

  }  
if(sum == 0)
  return 1;  
else return -1;
    
}    

}

示例#2

文件： BSTProblemSet1.cpp 项目： mururaj/Algorithms

int hasPathSum(Node *root,int sumValue,int parentSumVal)
{
	static char firstCall = 'Y';

	// Set parentSumval to 0 for first time call
	if (firstCall == 'Y')
	{
		parentSumVal = 0;
		firstCall = 'N';
	}
	// Sum false if no root
	if (!root)
	{
		return 0;
	}

	// Compute the sum of current path including this node
	int currentPathSum = root->data + parentSumVal;

	// if sum value matching return true
	if ( !root->leftChild && !root->rightChild &&
		currentPathSum == sumValue)
	{
		return 1;
	}

	return (
		(hasPathSum(root->leftChild,sumValue,currentPathSum)) 
			|| 
		(hasPathSum(root->rightChild,sumValue,currentPathSum))
		);
}

示例#3

文件： solution.cpp 项目： hxdone/puzzles

 bool hasPathSum(TreeNode* root, int sum) {
     if (!root) return false;
     else if (root->left == NULL && root->right == NULL) // leaf
         return root->val == sum;
     else // non-leaf
         return (hasPathSum(root->left, sum-root->val) || hasPathSum(root->right, sum-root->val));
 }

示例#4

文件： Path Sum.cpp 项目： yuchaozh/LeetCode

 bool hasPathSum(TreeNode *root, int sum) 
 {
     if (!root) {return false;}
     // root->left == NULL && root->right == NULL, then it is a leaf node
     if ((root->left == NULL) && (root->right == NULL) && (sum - root->val == 0)) {return true;}
     return (hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val));
 }

示例#5

文件： Path Sum.cpp 项目： septem776/LeetCode

 bool hasPathSum(TreeNode *root, int sum) {
     // Start typing your C/C++ solution below
     // DO NOT write int main() function
     if(root == NULL)
         return false;
     if(root->left == NULL && root->right == NULL)
     {
         if(root->val == sum)
         {
             return true;
         }
         return false;
     }
     bool ret = false;
     if(root->left)
     {
         ret = hasPathSum(root->left, sum-root->val);
     }
     if(!ret && root->right)
     {
         ret = hasPathSum(root->right, sum-root->val);
     }
     return ret;
     
 }

示例#6

文件： 112.cpp 项目： raynacode/leetcode

 bool hasPathSum(TreeNode* root, int sum) {
     if (!root)
         return false;
     if (!root->left && !root->right && root->val == sum) // leaf means both left and right child are NULL
         return true;
     return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
 }

示例#7

文件： 19.root-to-leaf-path-sum-equal-to-a-given-number.cpp 项目： linearregression/geeksforgeeks

bool hasPathSum(node *root, int sum){
	if(root == NULL || sum<0)
		return false;
	if(root->left == NULL && root->right == NULL && sum == root->data)
		return true;
	return hasPathSum(root->left, sum-root->data) || hasPathSum(root->right, sum-root->data);
}

示例#8

文件： solution.cpp 项目： veryflying/ltcd

 bool hasPathSum(TreeNode* root, int sum) {
     if(root == NULL)
         return false;
     if (root->left == NULL and root->right == NULL)
         return sum == root->val;
     return hasPathSum(root->left, sum - root->val) or hasPathSum(root->right, sum - root->val);
 }

示例#9

文件： 112. Path Sum.cpp 项目： Huijuan2015/MyLeetcodeSolutions

 bool hasPathSum(TreeNode* root, int sum) {
     if(!root) return false;
     if(!root->left && !root->right) return sum == root->val;
     else{
         return hasPathSum(root->right, sum-root->val) || hasPathSum(root->left, sum-root->val);
     }
 }

示例#10

文件： Path Sum.cpp 项目： mxer/leetcode

 bool hasPathSum(TreeNode* root, int sum) {
     if (root == NULL) return false;
     else if (root->val == sum && root->left ==  NULL && root->right == NULL) return true;
     if (root->left && hasPathSum(root->left, sum - root->val)) return true;
     if (root->right && hasPathSum(root->right, sum - root->val)) return true;
     return false;
 }

示例#11

文件： pathsum.cpp 项目： chaishi/problems

/*
 * I
 * */
bool hasPathSum(TreeNode *root, int sum){
    if(!root)    return false;
    if(root->left == NULL && root->right == NULL && sum == 0)   return true;
    sum -= root->val;
    if(root->left != NULL  && hasPathSum(root->left, sum))     return true;
    if(root->right != NULL && hasPathSum(root->right, sum))    return true;
    return false;
}

示例#12

文件： hasPathSum.cpp 项目： ysdeal/LeetCode

bool hasPathSum(TreeNode *root, int num){
    if(root==NULL)
        return false;
    if(sum==root->val && !(root->left || root->right))
        return true;
    else
        return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
}

示例#13

文件： rootToLeafSum.c 项目： gaurilab/algorithms

bool hasPathSum(Node *root, int sum) {
	if (!root) {
		return false;
	}
	if (isLeaf(root) && sum == root->data) return true;
	return (hasPathSum(root->right, sum- root->data)|| hasPathSum(root->left, sum - root->data));
	
}

示例#14

文件： Path Sum.cpp 项目： zackkk/leetcode

 // straight-forward implementation
 bool hasPathSum(TreeNode *root, int sum) {
     if(root == NULL)
         return false;
     if(root->left == NULL && root->right == NULL){
         return root->val == sum ? true : false;
     }
     return (hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val));
 }

示例#15

bool hasPathSum(Node *node, int sum)
{  
    
   if(node->left==NULL && node->right==NULL) return sum==(node->data);
   if(node->left!=NULL && hasPathSum(node->left, sum - node->data)) return true;
   if(node->right!=NULL && hasPathSum(node->right, sum - node->data)) return true;
   return false;
}

示例#16

文件： leetcode112.cpp 项目： JeraKrs/ACM

		bool hasPathSum(TreeNode* root, int sum) {
			if (root == NULL) return false;

			if (root->left == NULL && root->right == NULL) return sum == root->val;
			else if (root->left == NULL) return hasPathSum(root->right, sum - root->val);
			else if (root->right == NULL) return hasPathSum(root->left, sum - root->val);
			return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
		}

示例#17

文件： pathSum.cpp 项目： asahinobori/leetcode

    bool hasPathSum(TreeNode* root, int sum) {
        if (root == nullptr) return false;

        if (root->left == nullptr && root->right == nullptr)
            return sum == root->val;
        return (hasPathSum(root->left, sum - root->val)
            || hasPathSum(root->right, sum - root->val));
    }

示例#18

文件： 112_Path_Sum.cpp 项目： Markz2z/Fuck-the-Leetcode

 bool hasPathSum(TreeNode* root, int sum) {
 	if(root) {
 		if(!root->left && !root->right && sum==root->val)
 			return true;
 		return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
 	}
 	return false;
 }

示例#19

文件： main.cpp 项目： bestswifter/LeetCode

int main(int argc, const char * argv[]) {
    TreeNode *root1 = TreeCreate(2,1,2);
    std::cout << hasPathSum(root1, 1) << std::endl;
    
    TreeNode *root2 = TreeCreate(15,5,4,8,11,INT_MAX,13,4,7,2,INT_MAX,INT_MAX,INT_MAX,INT_MAX,INT_MAX,1);
    std::cout << hasPathSum(root2, 22) << std::endl;
    return 0;
}

示例#20

文件： path-sum.cpp 项目： zhoulike/algorithms

 bool hasPathSum(TreeNode *root, int sum) {
     if (!root)
         return false;
     else if (root->val == sum && !root->left && !root->right)
         return true;
     else 
         return hasPathSum(root->left, sum - root->val) ||
                hasPathSum(root->right, sum - root->val);
 }

示例#21

文件： PathSum.cpp 项目： rainlee/leetcode-jecklee

 bool hasPathSum(TreeNode *root, int sum) {
     if (NULL == root)
         return false;
     
     if ((NULL == root->left) && (NULL == root->right))  // leaf node
         return (sum == root->val);
     
     return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
 }

示例#22

文件： BST.c 项目： richzw/CodeHome

/*
* Given a tree and a sum, return true if there is a path from the root
* down to a leaf, such that adding up all the values along the path
* equals the given sum.
*/
int hasPathSum(struct node* node, int sum){
   if (NULL == node)
       return (sum == 0);
   else{
       int subSum = sum - node->data;
       return (hasPathSum(node->left, subSum) ||
               hasPathSum(node->right, subSum));
   }
}

示例#23

文件： Path Sum.cpp 项目： houjingbiao/leetcode

	bool hasPathSum(TreeNode *root, int sum, int curr_sum) {
		curr_sum += root->val;
		if(root->left == NULL && root->right == NULL && sum == curr_sum)
			return true;
		else if( (root->left && hasPathSum(root->left, sum, curr_sum))
			|| (root->right && hasPathSum(root->right, sum, curr_sum)))
			return true;
		return false;
	}

示例#24

文件： printPaths.c 项目： syamgk/Data_Structures

/* Given a tree and a sum, return true if there is a path from the root
   down to a leaf, such that adding up all the values along the path
   equals the given sum. */
int hasPathSum(struct node* root, int sum)
{
	if(root == 0)
		return sum ==0;
	else {
		int newsum = sum - root->data;
		return (hasPathSum(root->left,newsum) || hasPathSum(root->right,newsum));
	}
}

示例#25

文件： 112_Path_Sum.cpp 项目： JonnyKong/LeetCode

bool hasPathSum(TreeNode* root, int sum) {
  if (!root)
    return 0;
  else if (root->left == NULL && root->right == NULL)
    return sum == root->val;
  else
    return (hasPathSum(root->left, sum - root->val) ||
            hasPathSum(root->right, sum - root->val));
}

示例#26

文件： pathSum.cpp 项目： bigship/leetcode_solutions

  bool hasPathSum(TreeNode *root, int sum) {
    if (!root) return false;
    if (root->left == nullptr && root->right == nullptr) {
      if (root->val == sum) return true;
    }

    int new_sum = sum - root->val;
    return hasPathSum(root->left, new_sum) || hasPathSum(root->right, new_sum);
  }

示例#27

文件： PathSum.c 项目： yangjin-unique/leetcode

/**
 * method 1: recursion.
 */
bool hasPathSum(struct TreeNode* root, int sum) {
    if (root == NULL)
        return 0;

    if (root->left == NULL && root->right == NULL) {
        return (sum == root->val);
    }
    return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
}

示例#28

文件： hasPathSum2.cpp 项目： dalanlan/algo

 bool hasPathSum(TreeNode* root, int sum) {
     if(root == NULL) {
         return false;
     }
     if(root->val == sum && !root->left && !root->right) {
         return true;
     }
     return hasPathSum(root->left, sum-root->val) || hasPathSum(root->right, sum-root->val);
 }

示例#29

文件： path-sum.cpp 项目： thufish/Mingliang.Liu-algorithm

 bool hasPathSum(TreeNode *root, int sum) {
     if (root == NULL)
         return false;
     // leaf node
     else if (root->left == NULL && root->right == NULL)
         return root->val == sum;
     else
         return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
 }

示例#30

文件： 112_path_sum.c 项目： eazow/leetcode

int hasPathSum(struct TreeNode* root, int sum) {
    if(root == NULL)
        return 0;
    else if(root->left==NULL && root->right==NULL)
        return sum==root->val;

    return hasPathSum(root->left, sum-root->val) || 
        hasPathSum(root->right, sum-root->val);
}