剑指Offer练习及其解析(python代码)：21-28(双指针，递归)

一.剑指 Offer 22. 链表中倒数第k个节点

双指针法：

1.先找到初始第k个数，前指针指向head，后指针指向第k节点

2.俩个指针同时向后移动，直到到达链表尾

代码：

#My solution
#32ms:98; 13.6mb: 100
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
        p = head
        for i in range(k):
            if p:
                p=p.next
            else: 
                return head
        while p:
            head = head.next
            p = p.next
        return head

 

二.剑指Offer 24. 反转链表

双指针法：

将当前指针的下一个节点指向前一指针，一次循环直到到达链表尾

代码：

#my Solution 双指针
#48ms:53;14.6mb:100

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

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

三.剑指Offer 25. 合并两个有序链表

伪双指针法：

cur为合成后指针，l1，l2两个链表指针，哪一个值小，哪一个当前节点合并进cur指针；

之后，小值的链表指针前进

代码：

#My Solution
#/56ms:93; 14.4:100

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        dum = cur = ListNode(0)
        while l1 != None and l2 != None:
            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

 

四.剑指Offer 27. 二叉树的镜像

递归代码：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

#My Solution
#38ms; 13.7 mb
class Solution:  
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        if root == None:
            return root
        if root.left != None:
            root.left = self.mirrorTree(root.left)
        if root.right != None:
            root.right = self.mirrorTree(root.right)
        root.right, root.left = root.left, root.right
        return root

五.剑指Offer 28. 对称的二叉树

递归法：

判断方法：判断二叉树是否对称，即判断两个对称节点中，一个的左子节点是否=另一个的右子节点，且一个的右子节点是否=另一个的左子节点；

初始：初始为根节点的左右子节点为对称节点；

递归：从根节点的左右子节点作为对称节点开始进行判断，每一对被判断的节点为对称节点，递归判断

代码：

#Mysolution
#44ms: 71; 14mb: 100;
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        def cur(L: TreeNode, R: TreeNode) -> bool:
            if not R and not L: return True
            if not R or not L or L.val != R.val: return False
            return cur(L.right, R.left) and cur(L.left, R.right)

        return cur(root.left, root.right) if root else True