菜鸡前端一块儿学算法(第三天)

https://juejin.im/post/5e4f46cc51882549507b045c

二叉树的遍历方式

须要树立一个意识就是好比有一个tree中插入一个值，并非在树的最后面插入这个节点，而是把这个树的子节点所有替换为该节点 下面是js对树的实现:

function TreeNode(val) {
    this.value = val;
    this.left = this.right = null;
}
复制代码

前序遍历

首先访问根节点，而后访问根节点的左子树，在访问根节点的右子树

function DLR(tree) {
    console.log(tree.value)
    if (tree.left) {
        DLR(tree.left)
    } 
    if (tree.right) {
        DLR(tree.right)
    }
}
复制代码

中序遍历

首先访问根节点的左子树，而后访问根节点，再访问根节点右子树

function DLR(tree) {
    if (tree.left) {
        DLR(tree.left)
    }
    console.log(tree.value)
    if (tree.right) {
        DLR(tree.right)
    }
}
复制代码

后序遍历

首先访问根节点的左子树，而后访问根节点的右子树，最后访问根节点

function DLR(tree) {
    if (tree.left) {
        DLR(tree.left)
    }
    if (tree.right) {
        DLR(tree.right)
    }
    console.log(tree.value);
}
复制代码

delete-node-in-a-bst

总结出算法除了套路，例如这道题我一看就知道用递归，这也算是进步了。此外还有具体分析这个题，这个二叉树是排序好的，就是左边的比右边小，递归

var deleteNode = function(root, key) {
    let node;
    // 取出子树在进行排序
    if (root === null) {
        return root;
    }
    if (key === root.val) {
        if (root.left === null) {
            return root.right;
        } else if (root.right === null) {
            return root.left;
        } else {
            node = root.right;
            while (node.left !== null) {
                node = node.left;
            }
            node.left = root.left;
            return root.right;
        }
    } else if (key > root.val) {
        root.right = deleteNode(root.right, key);
    } else {
        root.left = deleteNode(root.left, key)
    }
    return root;
};
复制代码

lowest-common-ancestor-of-a-binary-tree

若是当前结点root等于NULL，则直接返回NULL
若是root等于p或者q，那这棵树必定返回p或者q
而后看递归左右子树（由于是递归，使用函数后能够认为左右子树已经算出告终果，用left和right表示;
此时若left为空，那最终结果只要看right； 若right为空，那最终结果只要看left;
若是left和right都非空，由于只给了p和q两个结点，都非空，说明一边一个，所以root是他们的最近公共祖先;
若是left和right都为空，则返回空

感受用文字不用容易理解能够用简单的例子来进行讲解

1
   / \
  2   8
 / \   
3   4   
复制代码

若是须要求导3、4和共同祖先，能够对比思考一下

var lowestCommonAncestor = function(root, p, q) {
    if (root === null) return null;
    if (root === p || root === q) {
        return root;
    }

    const left = lowestCommonAncestor(root.left, p, q);
    const right = lowestCommonAncestor(root.right, p, q);
    if (left !== null && right !== null) {
        return root;
    } else if (left !== null) {
        return left;
    } else if (right !== null) {
        return right;
    }
    return null;
};
复制代码

kth-largest-element-in-an-array

这道题虽然简单，但好歹是本身实现的

var findKthLargest = function(nums, k) {
    const sortArr = nums.sort((a, b) => b - a);
    return sortArr[k - 1]
};
复制代码

动态规划

动态规划听着逼格挺高的，先学习一下，究竟是怎么回事。 具体的文章参考什么是动态规划 就是将复杂的内容进行简单化，非要给他取一个高大上的名字，平时咱们对斐波那契的求职就体验了这个

// 1
function fibonacci(n) {
    if (n < 2) {
        return 1;
    }
    return fibonacci(n - 1) + fibonacci(n - 2)
}
// 2
function fibonacci(n) {
    let i = 0;
    const result = {};
    while (i < n) {
        if (i < 2) {
            return 2;
        } else {
            result[i] = result[i - 1] + result[i - 2]
        }
        i++;
    }
    return result[-1]
}
复制代码

今天看了一会电视剧，学的不是不少，明天早点起床，开始学习