精选留言(16)

• 
  不记年

  2018-10-26

  老师 ，你讲的很好，但是到我分析的时候往往想不到，所以我想知道关于算法有什么分析的套路吗

  作者回复: 最最开始的时候，关键就是要考积累。这个时期基本上是积累算法和解题的原知识的时期，所以将其记住反复练习更加重要。

  

   8
• 
  DY

  2018-10-31

  通俗易懂👍👍，非科班出生的我都有所领悟😁😁

  

   4
• 
  布鲁boy

  2019-05-13

  java没有递归的方式
  class Solution {
      public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
          //非递归的方式
          while(root != null){
              //判断两个值是否都小于根节点
              if(p.val < root.val && q.val < root.val){
                  //直接排查左节点
                  root = root.left;
              }
              //判断两个值是否都大于右节点
              else if(p.val > root.val && q.val > root.val){
                  root = root.right;
              }
              else{
                  return root;
              }
          }
         return null;
      }
  }

  展开

  作者回复: 帅！

   2

   2
• 
  leilei

  2018-12-05

  老师，可能是我脑子转弯太慢，理解LCA递归的时候，下面这段代码就没压力，视频中的代码就转不过来弯，老师看一下下面这段代码的效率会有影响吗？
  /*查找二叉树中两个结点最低公共祖先结点*/
  struct node* LCA(struct node *root, struct node *p, struct node *q)
  {
      if (hasNode(root->left, p) && hasNode(root->left, q)) //p和q都在左子树中
          return LCA(root->left, p, q);
      if (hasNode(root->right, p) && hasNode(root->right, q)) //p和q都在右子树中
          return LCA(root->right, p, q);
      return root; //p和q一个在左子树，一个在右子树中，直接返回root
  }
   
  /*判断root为根的树是否包含结点p*/
  bool hasNode(struct node* root, struct node* p)
  {
      if (!root) return false;
      if (root == p)
          return true;
      return hasNode(root->left, p) || hasNode(root->right, p);
  }

  展开

   1

   1
• 
  拎着自己飞

  2019-11-29

  老师您好
  您说第一种解法是O(n)
  我有点疑惑
  为何不是O(logn)呀
  找path的过程 一次下降个level 应该是logn吧？
  可能我哪里想错了 希望老师指点下 谢啦
  

  展开

  

  
• 
  小米豆

  2019-06-23

  麻烦一行行的手敲代码来讲解思路吧 有些函数都不知道干啥的 听不懂啊。如果是看整体代码结果 就没必要购买视频课程了。崩溃

  

  
• 
  郑晨Cc

  2019-04-24

  其实关于 最后的三目表达式 return left==null ? right == null ? null : right : right!=null ? root : left;
  这样去写 不仅仅是有美感 这样的逻辑判断过程是效率最高的 我把它还原成if 和 else 是这样的
                 if(left == null){
              if(right == null) return null;
              else{
                  return right;
              }
          }else{
              if(right!=null){
                  return root;
              }else{
                  return left;
              }
          }
  童鞋们可以看到 这个逻辑链条的构建 其实是一颗逻辑二叉搜索树 也就是说每次的逻辑判断都不会跟之前有重复
  那么 有的童鞋可能会这样去写 if else语句
                  if(left!=null&&right!=null) return root;
       if(left==null&&right==null) return null;
          return left==null ? right:left;
  这样的写法可读性很强 但是逻辑判断其实是有冗余的

  展开

  作者回复: 👍👍👍

   1

  
• 
  张xy

  2019-04-14

  老师，第一个算法是不是有问题啊？第一个算法，不针对二叉搜索树的那个，左子树和右子树只调用了一遍lowest算法，这个存在找到的不是最近的公共祖先问题啊？假如p,q分别是root的左子树中的某个节点的左右子树，也就是root的“重孙子”节点，那么按理说应该返回root的“孙子”值，但是你的算法只查找一遍，那么只能返回root的“儿子”节点，也就是说只能把结果值都限定在了root、root.left、root.right这三个上了？？？

  作者回复: 整个是递归下去的，也就是说每个左右子树都会进行检查。

  

  
• 
  dll

  2019-03-15

  哈哈，我是个女生，以前老是害怕看算法，学算法，但是随着工作时间的增加，真的越来越能领会到代码的魅力，原来还可以这样写，坚持积累练习思考很重要。

  

  
• 
  Derek

  2019-02-06

  GO语言版本实现235
  package main
  
  import (
      "fmt"
  )
  
  type TreeNode struct {
      Left *TreeNode
      Right *TreeNode
      Val int
  }
  
  func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
      // 说明找到了共同祖先
      if root == nil || root == p || root == q {
          return root
      }
  
      // 如果p和q都小于root，去左边找。如果p和q都大于root，去右边找。
      if root.Val > max(p.Val, q.Val) {
          return lowestCommonAncestor(root.Left, p, q)
      } else if root.Val < min(p.Val, q.Val) {
          return lowestCommonAncestor(root.Right, p, q)
      } else {
          return root
      }
  }
  
  func max(x, y int) int {
      if x > y {
          return x
      }
      return y
  }
  
  func min(x, y int) int {
      if x < y {
          return x
      }
      return y
  }
  
  func main() {
      root := &TreeNode{
          Val: 6,
          Left: &TreeNode{
              Val: 2,
              Left: &TreeNode{
                  Val: 0,
              },
              Right: &TreeNode{
                  Val: 4,
                  Left: &TreeNode{
                      Val: 3,
                  },
                  Right: &TreeNode{
                      Val: 5,
                  },
              },
          },
          Right: &TreeNode{
              Val: 8,
              Left: &TreeNode{
                  Val: 7,
              },
              Right: &TreeNode{
                  Val: 9,
              },
          },
      }
  
      fmt.Println(lowestCommonAncestor(root, root.Left, root.Right)) // 6
      fmt.Println(lowestCommonAncestor(root, root.Left, root.Left.Right)) // 2
  }
  

  展开

  

  
• 
  Trevor.赤

  2019-01-12

  func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
       if (root == nil||root == p || root == q){
           return root
       }
       left := lowestCommonAncestor(root.Left,p,q)
       right := lowestCommonAncestor(root.Right,p,q)
       if (left != nil&& right !=nil) {
           return root
       } else if left != nil {
           return left
       } else {
           return right
       }
       return root
  }

  展开

  

  
• 
  唯她命

  2018-12-07

  @马建华同学 ，仔细看题目
  
  题目中明确说明了
  
  说明:
  
  所有节点的值都是唯一的。
  p、q 为不同节点且均存在于给定的二叉树中。
  

  展开

  

  
• 
  疯琴

  2018-11-27

  235递归法第二个if写成elif就更快了

  

  
• 
  Clear

  2018-11-04

  老师你好，关于这个课程代码讲解，我目前的方法是：先去看题目想一下思路，然后再看视频讲解，但是思路总是会遇到死胡同，或者是思路有了代码时间总是有点问题。这种情况有没有好一点的建议。

  

  
• 
  马建华

  2018-11-03

  老师，这题的解法貌似有问题，如果树是{1,#,2,#,3,#,4,#,5}，p = 3, q = 8，也就是说有其中一个不存在树中，应该返回None，但是直接就返回3了

   1

  
• 
  包包

  2018-11-02

  看到老师说开始的时候记住和反复练习我就放心了。对于树的题真的是找不到要领，已经刷不是第一遍了，每次还是会卡壳，同问老师有没有针对树的类似模板或者做题套路？

  

  