23.24.25

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

限制：

0 <= 节点个数 <= 5000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        def helper(last,cur):
            if not cur: return last
            nex = cur.next
            cur.next = last
            if not nex: return cur           
            return helper(cur,nex)
        return helper(None,head)

思路：

1. 三指针，运用了递归思想。
2. helper的作用就是将last->cur 变成last<-cur ，有因为cur的指针变了，所以需要一个nex变量存储之前cur指向的节点。然后再次调用自己，这是里面的参数就变成了（cur，nex），就这样一直递归下去，直到 nex的节点为空。

---

25.输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

示例1：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
限制：

0 <= 链表长度 <= 1000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        dum = cur = ListNode(0)
        while l1 and l2:
            if l1.val<l2.val:
                cur.next,l1 = l1,l1.next
            else:
                cur.next,l2 = l2,l2.next
            cur = cur.next
        cur.next = l1 if l1 else l2
        return dum.next

思路：

1. 因为要合并两个链表，而合并链表开始的时候是无节点的，所以需要先整一个假的头结点。 dum
2. dum就不动了，只动cur，当l1 l2节点不为空的时候，开始比对这两个节点的值，谁小谁入合并链表。cur.next = 并入链表的节点， 被选择的那个链表节点再往后移动一位。 cur也往后移动一位
3. 当其中一个链表移动完了。剩余那个链表就可以不用判断全部入 合并链表。
4. 返回的时候 不要返回dum。

26.输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)

B是A的子结构， 即 A中有出现和B相同的结构和节点值。

例如:
给定的树 A:

 3
/ \

4 5
/
1 2
给定的树 B：

4
/
1
返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。

示例 1：

输入：A = [1,2,3], B = [3,1]
输出：false
示例 2：

输入：A = [3,4,5,1,2], B = [4,1]
输出：true
限制：

0 <= 节点个数 <= 10000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shu-de-zi-jie-gou-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：

https://leetcode-cn.com/problems/shu-de-zi-jie-gou-lcof/solution/mian-shi-ti-26-shu-de-zi-jie-gou-xian-xu-bian-li-p/
贴个大佬的链接吧。 题解中有图 比较好理解。

class Solution:
    def isSubStructure(self, A: TreeNode, B: TreeNode) -> bool:
        def recur(A,B):
            if not B: return True
            if not A or A.val != B.val: return False
            return recur(A.left,B.left) and recur(A.right,B.right)
        return bool(A and B) and (recur(A,B) or self.isSubStructure(A.right,B) or self.isSubStructure(A.left,B))