不知道是些什么代码了

Author: Z1hgq

BinaryTree/sortedListToBST.ts

@@ -0,0 +1,66 @@
+class ListNode {
+    val: number;
+    next: ListNode | null;
+    constructor(val?: number, next?: ListNode | null) {
+        this.val = val === undefined ? 0 : val;
+        this.next = next === undefined ? null : next;
+    }
+}
+class TreeNode {
+    val: number;
+    left: TreeNode | null;
+    right: TreeNode | null;
+    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+        this.val = val === undefined ? 0 : val;
+        this.left = left === undefined ? null : left;
+        this.right = right === undefined ? null : right;
+    }
+}
+
+function sortedListToBST(head: ListNode | null): TreeNode | null {
+    if (!head) {
+        return null;
+    }
+    if (!head.next) {
+        return new TreeNode(head.val);
+    }
+    if (!head.next.next) {
+        let t = new TreeNode(head.val);
+        t.left = new TreeNode(head.next.val);
+        return t;
+    }
+    let pre: ListNode = head;
+    let p: ListNode = pre.next;
+    let q = p.next;
+    // 一次跳两个元素，找到链表的中间元素p
+    while (p && q) {
+        pre = pre.next;
+        p = p.next;
+        q = q.next.next;
+    }
+    console.log(p);
+    // 
+    pre.next = null;
+    let root = new TreeNode(p.val);
+    root.left = sortedListToBST(head);
+    root.right = sortedListToBST(p.next);
+    return root;
+}
+
+const LL = {
+    val: -10,
+    next: {
+        val: -3,
+        next: {
+            val: 0,
+            next: {
+                val: 5,
+                next: {
+                    val: 9,
+                    next: null
+                }
+            }
+        }
+    }
+}
+console.log(JSON.stringify(sortedListToBST(LL)));

LinkedList.js

@@ -171,4 +171,5 @@ const LinkedList = function () {
   this.getHead = function () {
     return head;
   };
-};
+};
+module.exports = LinkedList;

huawei/intersection.js

@@ -0,0 +1,73 @@
+const source = [
+    [0, 3],
+    [1, 3],
+    [3, 5],
+    [3, 6]
+];
+source.sort((a, b) => a[0] > b[0]);
+function Intersection(arr) {
+    const len = arr.length;
+    let res = [];
+    let flag = true;
+    for (let i = 0; i < len - 1; i++) {
+        for (let j = i + 1; j < len; j++) {
+            if (arr[i][1] >= arr[j][0]) {
+                res.push([arr[j][0], arr[i][1]]);
+                flag = false;
+            }
+        }
+    }
+    // 处理没有交集的情况
+    if (flag) {
+        return 'None';
+    }
+    // 去除重复的交集
+    res = filter(res);
+    // 结果取并集，这里做错了
+    return merge(res);
+}
+function filter(arr) {
+    const len = arr.length;
+    if (len === 0) {
+        return arr;
+    }
+    const newArr = [];
+    const strArr = [];
+    newArr.push(arr[0]);
+    strArr.push(JSON.stringify(arr[0]));
+    for (let i = 1; i < len; i++) {
+        if (strArr.indexOf(JSON.stringify(arr[i])) === -1) {
+            newArr.push(arr[i]);
+            strArr.push(JSON.stringify(arr[i]));
+        }
+    }
+    return newArr;
+}
+
+// var merge = function (intervals) {
+//     if (!intervals.length) return []
+//     if (intervals.length === 1) return intervals
+//     intervals.sort((a, b) => a[0] - b[0])
+//     let start = intervals[0][0], end = intervals[0][1], res = []
+//     for (let interval of intervals) {
+//         if (interval[0] <= end) { 
+//             end = Math.max(end, interval[1])
+//         } else { 
+//             res.push([start, end])
+//             start = interval[0]
+//             end = interval[1]
+//         }
+//     }
+//     res.push([start, end])
+//     return res
+// };
+
+const result = Intersection(source);
+result.sort((a, b) => a[0] > b[0]);
+if (result !== 'None') {
+    for (const item of result) {
+        console.log(item.join(' '));
+    }
+} else {
+    console.log('None');
+}

strings/countSubstrings.ts

@@ -0,0 +1,20 @@
+function countSubstrings(s: string): number {
+    let count = 0;
+    const dp: number[] = [];
+    for (let i = 0; i < s.length; i++) {
+        dp[i] = 1;
+        // 每一个
+        count ++;
+        for (let j = 0; j < i; j++) {
+            if (s[j] === s[i] && dp[i] === 1) {
+                dp[j] = 1;
+                count++;
+            } else {
+                dp[j] = 0;
+            }
+        }
+        console.log(dp);
+    }
+    return count;
+};
+console.log(countSubstrings('asddsaasd'));