add q513 java, cpp, go

Author: godcrampy

513-find-bottom-left-tree-value/cpp/main.cpp

@@ -0,0 +1,59 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
+ * right(right) {}
+ * };
+ */
+class Solution {
+ public:
+  int findBottomLeftValue(TreeNode* root) {
+    return findLeftMostAndDepth(root, 0).first->val;
+  }
+
+  pair<TreeNode*, int> findLeftMostAndDepth(TreeNode* root, int depth) {
+    bool left = false;
+    bool right = false;
+    TreeNode* leftNode = NULL;
+    TreeNode* rightNode = NULL;
+    int leftDepth = 0;
+    int rightDepth = 0;
+
+    if (root->left != NULL) {
+      left = true;
+      auto p = findLeftMostAndDepth(root->left, depth + 1);
+      leftDepth = p.second;
+      leftNode = p.first;
+    }
+
+    if (root->right != NULL) {
+      right = true;
+      auto p = findLeftMostAndDepth(root->right, depth + 1);
+      rightDepth = p.second;
+      rightNode = p.first;
+    }
+
+    if (left && right) {
+      if (rightDepth > leftDepth) {
+        return {rightNode, rightDepth};
+      } else {
+        return {leftNode, leftDepth};
+      }
+    }
+
+    if (left) {
+      return {leftNode, leftDepth};
+    }
+
+    if (right) {
+      return {rightNode, rightDepth};
+    }
+
+    return {root, depth};
+  }
+};

513-find-bottom-left-tree-value/cpp/main2.cpp

@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
+ * right(right) {}
+ * };
+ */
+class Solution {
+ public:
+  int findBottomLeftValue(TreeNode* root) {
+    queue<TreeNode*> q;
+    q.push(root);
+
+    while (!q.empty()) {
+      root = q.front();
+      q.pop();
+
+      if (root->right != NULL) {
+        q.push(root->right);
+      }
+
+      if (root->left != NULL) {
+        q.push(root->left);
+      }
+    }
+
+    return root->val;
+  }
+};

513-find-bottom-left-tree-value/go/main.go

@@ -0,0 +1,60 @@
+package main
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+
+type NodeDepth struct {
+	Node  *TreeNode
+	Depth int
+}
+
+func findBottomLeftValue(root *TreeNode) int {
+	return findBottomLeftAndDepth(root, 0).Node.Val
+}
+
+func findBottomLeftAndDepth(root *TreeNode, depth int) NodeDepth {
+	left := false
+	right := false
+	leftDepth := 0
+	rightDepth := 0
+	var leftNode *TreeNode
+	var rightNode *TreeNode
+
+	if root.Left != nil {
+		left = true
+		nd := findBottomLeftAndDepth(root.Left, depth+1)
+		leftDepth = nd.Depth
+		leftNode = nd.Node
+	}
+
+	if root.Right != nil {
+		right = true
+		nd := findBottomLeftAndDepth(root.Right, depth+1)
+		rightDepth = nd.Depth
+		rightNode = nd.Node
+	}
+
+	if left && right {
+		if rightDepth > leftDepth {
+			return NodeDepth{Node: rightNode, Depth: rightDepth}
+		} else {
+			return NodeDepth{Node: leftNode, Depth: leftDepth}
+		}
+	}
+
+	if left {
+		return NodeDepth{Node: leftNode, Depth: leftDepth}
+	}
+
+	if right {
+		return NodeDepth{Node: rightNode, Depth: rightDepth}
+	}
+
+	return NodeDepth{Node: root, Depth: depth}
+}

513-find-bottom-left-tree-value/go/main2.go

@@ -0,0 +1,28 @@
+package main
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func findBottomLeftValue(root *TreeNode) int {
+	q := []*TreeNode{root}
+
+	for len(q) != 0 {
+		root = q[0]
+		q = q[1:]
+
+		if root.Right != nil {
+			q = append(q, root.Right)
+		}
+
+		if root.Left != nil {
+			q = append(q, root.Left)
+		}
+	}
+
+	return root.Val
+}

513-find-bottom-left-tree-value/java/Solution.java

@@ -0,0 +1,58 @@
+/**
+ * Definition for a binary tree node. public class TreeNode { int val; TreeNode left; TreeNode
+ * right; TreeNode() {} TreeNode(int val) { this.val = val; } TreeNode(int val, TreeNode left,
+ * TreeNode right) { this.val = val; this.left = left; this.right = right; } }
+ */
+class Solution {
+  public class NodeDepth {
+    public final TreeNode node;
+    public final int depth;
+
+    public NodeDepth(TreeNode node, int depth) {
+      this.node = node;
+      this.depth = depth;
+    }
+  }
+
+  public int findBottomLeftValue(TreeNode root) {
+    return (findBottomLeftAndDepth(root, 0).node.val);
+  }
+
+  public NodeDepth findBottomLeftAndDepth(TreeNode root, int depth) {
+    boolean left = root.left != null;
+    boolean right = root.right != null;
+    TreeNode leftNode = null;
+    TreeNode rightNode = null;
+    int leftDepth = 0;
+    int rightDepth = 0;
+
+    if (left) {
+      NodeDepth nd = findBottomLeftAndDepth(root.left, depth + 1);
+      leftNode = nd.node;
+      leftDepth = nd.depth;
+    }
+
+    if (right) {
+      NodeDepth nd = findBottomLeftAndDepth(root.right, depth + 1);
+      rightNode = nd.node;
+      rightDepth = nd.depth;
+    }
+
+    if (!left && !right) {
+      return new NodeDepth(root, depth);
+    }
+
+    if (!left) {
+      return new NodeDepth(rightNode, rightDepth);
+    }
+
+    if (!right) {
+      return new NodeDepth(leftNode, leftDepth);
+    }
+
+    if (rightDepth > leftDepth) {
+      return new NodeDepth(rightNode, rightDepth);
+    }
+    return new NodeDepth(leftNode, leftDepth);
+  }
+}

513-find-bottom-left-tree-value/java/Solution2.java

@@ -0,0 +1,24 @@
+/**
+ * Definition for a binary tree node. public class TreeNode { int val; TreeNode left; TreeNode
+ * right; TreeNode() {} TreeNode(int val) { this.val = val; } TreeNode(int val, TreeNode left,
+ * TreeNode right) { this.val = val; this.left = left; this.right = right; } }
+ */
+class Solution {
+  public int findBottomLeftValue(TreeNode root) {
+    Queue<TreeNode> q = new LinkedList<>();
+    q.add(root);
+    while (!q.isEmpty()) {
+      root = q.remove();
+
+      if (root.right != null) {
+        q.add(root.right);
+      }
+
+      if (root.left != null) {
+        q.add(root.left);
+      }
+    }
+
+    return root.val;
+  }
+}