打败算法第二节之单链表、二叉树

---

前言

今天准备了四道题，一起来打卡学习吧！

---

1.相同的树

• 简单，100题 K个一组翻转链表
• 题目描述：给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
• 输入：p = [1,2,3], q = [1,2,3]
  输出：true

//二叉树数据结构
public class TreeNode {
      int val;
      TreeNode left;
      TreeNode right;
      TreeNode() {}
      TreeNode(int val) { this.val = val; }
      TreeNode(int val, TreeNode left, TreeNode right) {
          this.val = val;
          this.left = left;
          this.right = right;
      }
 }

• 思路：递归，当 当前两个节点的值相同并且其左右子树都相同的二叉树才是相同的树。

public boolean isSameTree(TreeNode p, TreeNode q) {
        if(p == null && q == null){
            return true;
        }
        //以下判断表示，当p和q有一个为空，一个不为空才会返回false。
        if(p != null ^ q != null){
            return false;
        }
        return p.val == q.val && isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }

2.两数相加

• 中等，2题 两数相加
• 题目描述：给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。请你将两个数相加，并以相同形式返回一个表示和的链表。你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
• 思路：先求出两个链表的长度，修改较长链表的节点值，将较长链表作为所求链表。定义两个节点分别表示较长链表的头节点curL和较短链表的头节点curS，两个链表从头节点开始遍历，计算进位值与两个节点值之和，据此计算下一位的进位值和当前节点的值，第一个循环的终止条件是较短链表遍历完成，之后再继续遍历较长链表剩余节点，最后如果当前进位数为1，则需要新建节点接到链表尾部，返回长链表的头节点即为所求。

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int len1 = getLength(l1);
        int len2 = getLength(l2);
        ListNode l = len1 > len2 ? l1 : l2;//较长链表头节点（固定不动）
        ListNode curS = l == l1?l2:l1;//较短链表遍历过程中的当前节点
        ListNode curL = l;//较长链表遍历过程中的当前节点
        ListNode last = curL;//一直跟踪curL，作用是所有遍历结束时，curL为空，这个时候进位信息需要接到返回的链表结尾，如果没有这个节点的话，最后curL为空，next指针不存在，连接不上，会报错
        int sum = 0;
        int carry = 0;
        while(curS != null){
            sum = curL.val + curS.val + carry;
            curL.val = sum % 10;
            carry = sum / 10;
            last = curL;
            curL = curL.next;
            curS = curS.next;
        }
        while(curL != null){
            sum = curL.val + carry;
            curL.val = sum % 10;
            carry = sum / 10;
            last = curL;
            curL = curL.next;
        }
        if(carry != 0){
            last.next = new ListNode(carry);
        }
        return l;
    }
    public int getLength(ListNode head){
        int len = 0;
        while (head != null){
            len ++;
            head = head.next;
        }
        return len;
    }

3.合并两个有序链表

• 简单，21题 合并两个有序链表
• 题目描述：将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
  输入：l1 = [1,2,4], l2 = [1,3,4]
  输出：[1,1,2,3,4,4]
• 思路：定义四个节点，head为新链表的头节点，为两个链表中头节点值较小的节点；cur为新链表在连接过程中的当前节点；cur1、cur2分别指向两个链表中待比较的第一个节点，当两个链表都不为空的时候，进行值的比较和节点的连接；当有一个链表为空时只需要将剩下链表的剩余节点连接到新链表即可。

public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(list1 == null || list2 == null){
            return list1 == null ? list2:list1;
        }
        ListNode head = list1.val > list2.val ? list2 : list1;
        ListNode cur = head;
        ListNode cur1 = head.next;
        ListNode cur2 = list1 == head ? list2 : list1;
        while(cur1 != null && cur2 != null){
            if(cur1.val < cur2.val){
                cur.next = cur1;
                cur1 = cur1.next;
            }else{
                cur.next = cur2;
                cur2 = cur2.next;
            }
            cur = cur.next;
        }
        cur.next = cur1 == null ? cur2 : cur1;
        return head;
    }

4.二叉树的最大深度

• 简单，104题 二叉树的最大深度
• 题目描述：给定一个二叉树 root ，返回其最大深度。二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。
  输入：root = [3,9,20,null,null,15,7]
  输出：3

//二叉树数据结构
public class TreeNode {
      int val;
      TreeNode left;
      TreeNode right;
      TreeNode() {}
      TreeNode(int val) { this.val = val; }
      TreeNode(int val, TreeNode left, TreeNode right) {
          this.val = val;
          this.left = left;
          this.right = right;
     }
 }
//方法定义
public int maxDepth(TreeNode root) {}

• 思路：递归遍历左右子树取最大值+1.

public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        return Math.max(maxDepth(root.left),maxDepth(root.right)) + 1;
    }

---

总结

欢迎大家讨论，如有错误还请指正！