剑指offerDayN之请教大佬

刷题看java已经小20天了，每天刷一点，递归还有debug一直都不会。

找大佬指导，又被骂惨，感觉自己好像不适合写代码，逻辑思维差，简单的或与非都看不出来，脑子不好真的是有差距的，再次怀疑自己，但只能继续加油。

在写代码的时候存在很严重的问题

1. 写代码写一堆 没有逻辑 没有框架(要按照想法写注释 先写什么后写什么 逻辑顺序弄清楚)
2. 递归出口  返回值   递归参数 这三个要好好思考

   package offer;
    
   import java.util.ArrayList;
   import java.util.List;
   import java.util.Stack;
    
   /*
   二叉树中和为某一值的路径
   递归出口 成立条件 不成立条件
   递归参数 边写边添加
    */
   public class Test37 {
       public static List<List<Integer>> getDistanceK(TreeNode root, List<List<Integer>> list, int k, int sum, List<Integer> tempList) {
           if (root == null) return null;
           tempList.add(root.val);
           sum = sum + root.val;
           //无孩子
           if (root.left == null && root.right == null) {
               if (sum == k) {//是想要的
                   list.add(tempList);
               }
               return list;
    
           } else if (root.left != null && root.right == null) {//有左孩子
    
               return getDistanceK(root.left, list, k, sum, tempList);
           } else if (root.left == null) {//只有右孩子
               return getDistanceK(root.right, list, k, sum, tempList);
           } else {//all
               getDistanceK(root.right, list, k, sum, new ArrayList<>(tempList));
               getDistanceK(root.left, list, k, sum, tempList);
               //  return list;
           }
   //
   //        List<Integer> temp = null;
   //        while (root != null) {
   //            sum += root.val;
   //            temp.add(root.val);
   //            if (sum == k) {
   //                break;
   //            } else if (root.left != null)
   //                return getDistanceK(root.left,list, k);
   //            else if (root.right != null)
   //                return getDistanceK(root.right, list,k);
   //        }
   //        list.add(temp);
    
           return list;
       }
    
       //先序遍历 非递归
       public static void preOrder(TreeNode root) {
           if (root == null) return;
           //构建栈
           Stack<TreeNode> stack = new Stack<>();
           stack.push(root);
           while (!stack.isEmpty()) {
               TreeNode treeNode = stack.pop();
               System.out.print(treeNode.val);
               if (treeNode.right != null)
                   stack.push(treeNode.right);
               if (treeNode.left != null)
                   stack.push(treeNode.left);
           }
       }
    
       public static void main(String[] args) {
           TreeNode treeNode = new TreeNode(5);
           treeNode.left = new TreeNode(3);
           treeNode.left.left = new TreeNode(2);
           treeNode.left.right = new TreeNode(4);
           treeNode.right = new TreeNode(7);
           treeNode.right.left = new TreeNode(6);
           treeNode.right.right = new TreeNode(8);
           //先序遍历结果
           preOrder(treeNode);
           System.out.println();
           List<List<Integer>> list = new ArrayList<>();
           System.out.println(getDistanceK(treeNode, list, 10, 0, new ArrayList<>()));
    
       }
   }
   

   树的子结构问题，首先保证能写出来然后再去简化代码。

   package offer;
    
   /*
   输入两棵二叉树A，B，判断B是不是A的子结构。
    */
   public class Test38 {
       /*
       public static boolean isSubTree(TreeNode treeA, TreeNode treeB) {
           //A是空树 返回false
           if (treeA == null) return false;
           if (treeB == null) return false;
           //A不能为空B也不能空
           //根节点数值相同 比较两个树的左右节点
           if (treeA.val == treeB.val) {
               if (treeA.left == null && treeA.right == null &&
                       treeB.left == null && treeB.right == null) {
                   return true;
               }
               if (treeA.left == null && treeB.left == null) {
                   if (treeA.right != null && treeB.right != null) {
                       if (isSubTree(treeA.right, treeB.right)) {
                           return true;
                       }
                   }
                   return false;
               } else if (treeA.left != null && treeB.left != null) {
                   if (!isSubTree(treeA.left, treeB.left)) {
                       return false;
                   }
                   if (treeA.right != null && treeB.right != null) {
                       return isSubTree(treeA.right, treeB.right);
                   }
                   return false;
               }
               return false;
           } else {
               //根节点不相同 A的左是否等于B A的右是否等于B
               return isSubTree(treeA.left, treeB) || isSubTree(treeA.right, treeB);
           }
       }
        */
       public static boolean isSubStructure(TreeNode treeA, TreeNode treeB) {
           //先判断 AB为空的情况 两个要是空就不行
           if (treeA == null || treeB == null) return false;
           //当两个的根节点数值相等  不相等找左子树 不相等找右子树
           //用或 只要有一种情况可以就行
           return fun(treeA, treeB) || isSubStructure(treeA.left, treeB) || isSubStructure(treeA.right, treeB);
    
       }
    
       public static boolean fun(TreeNode treeA, TreeNode treeB) {
           //判断A B的根节点都相等的情况
           //只有一个节点相等 指向的下一个null
           if (treeB == null) return true;
           //当A走到没有节点的时候后 B还有则不相等
           //A B 的数值不相等 则不是子结构
           if (treeA == null || treeA.val != treeB.val)
               return false;
           //左右两边都相等才可以
           return fun(treeA.left, treeB.left) && fun(treeA.right, treeB.right);
       }
    
       public static void main(String[] args) {
           TreeNode node6 = new TreeNode(6, null, null);
           TreeNode node5 = new TreeNode(5, null, null);
           TreeNode node4 = new TreeNode(4, null, null);
           TreeNode node3 = new TreeNode(3, node6, null);
           TreeNode node2 = new TreeNode(2, node4, node5);
           TreeNode node1 = new TreeNode(1, node2, node3);
           System.out.println(isSubStructure(node1, node3));
       }
   }
   

   多用if-else不丢人，写不出来才丢人，不要一口吃个胖子，多写多debug才行。

3. 刷题+springboot框架+github小项目 努力才能有收货

4. 在问为什么我每天都很困呢？因为你没有信念，没有重要的事做，当你非常有动力做一件事肯定能起来，现在还不起来小心失业哦