feat: finish No.1026

Author: BaffinLee

1001-1100/1026. Maximum Difference Between Node and Ancestor.md

@@ -0,0 +1,88 @@
+# 1026. Maximum Difference Between Node and Ancestor
+
+- Difficulty: Medium.
+- Related Topics: Tree, Depth-First Search, Binary Tree.
+- Similar Questions: .
+
+## Problem
+
+Given the ```root``` of a binary tree, find the maximum value ```v``` for which there exist **different** nodes ```a``` and ```b``` where ```v = |a.val - b.val|``` and ```a``` is an ancestor of ```b```.
+
+A node ```a``` is an ancestor of ```b``` if either: any child of ```a``` is equal to ```b``` or any child of ```a``` is an ancestor of ```b```.
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2020/11/09/tmp-tree.jpg)
+
+```
+Input: root = [8,3,10,1,6,null,14,null,null,4,7,13]
+Output: 7
+Explanation: We have various ancestor-node differences, some of which are given below :
+|8 - 3| = 5
+|3 - 7| = 4
+|8 - 1| = 7
+|10 - 13| = 3
+Among all possible differences, the maximum value of 7 is obtained by |8 - 1| = 7.
+```
+
+Example 2:
+
+![](https://assets.leetcode.com/uploads/2020/11/09/tmp-tree-1.jpg)
+
+```
+Input: root = [1,null,2,null,0,3]
+Output: 3
+```
+
+ 
+**Constraints:**
+
+
+	
+- The number of nodes in the tree is in the range ```[2, 5000]```.
+	
+- ```0 <= Node.val <= 105```
+
+
+
+## Solution
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxAncestorDiff = function(root) {
+    return helper(root.val, root.val, root);
+};
+
+var helper = function(max, min, node) {
+    if (!node) return 0;
+    var newMax = node.val > max ? node.val : max;
+    var newMin = node.val < min ? node.val : min;
+    return Math.max(
+        Math.abs(max - node.val),
+        Math.abs(min - node.val),
+        node.left ? helper(newMax, newMin, node.left) : 0,
+        node.right ? helper(newMax, newMin, node.right) : 0,
+    );
+};
+```
+
+**Explain:**
+
+use dfs to visit every node in the tree, carry the maximum and minimum number all the way down, the result should be |max - node.val| or |min - node.val|
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).