文章目录
- 剑指 Offer 22. 链表中倒数第k个节点
- 剑指 Offer 24. 反转链表
- 剑指 Offer 27. 二叉树的镜像
- 剑指 Offer 40. 最小的k个数
剑指 Offer 22. 链表中倒数第k个节点
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。
示例：
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
# Definition for singly-linked list.
class ListNode(object):
def __init__(self, x):
self.val = x
self.next = None
# # 解法一：
# # 1.遍历链表，将节点存入列表中
# # 2.返回第-k个节点即可
class Solution():
def getKthFromEnd(self, head, k) :
res = []
while head:
res.append(head)
head = head.next
return res[-k]
# 解法二：
# 方法: 双指针求解
# 思路: 第一个指针先移动k步，然后第二个指针再从头开始，这个时候这两个指针同时移动，
# 当第一个指针到链表的末尾的时候，返回第二个指针即可
class Solution():
def getKthFromEnd(self, head, k):
first, second = head, head
#1: first 指针移动k步
while k > 0:
first = first.next
k -= 1
#2: 两个指针同时向前移动
while first is not None:
first, second = first.next, second.next
return second
# 解法三：
# 先遍历链表计算长度，再从头找出目标节点
class Solution():
def getKthFromEnd(self, head, k):
count = 0
node = head
while node:
count += 1
node = node.next
node = head
n = count - k
while n:
node = node.next
n -= 1
return node
if __name__=='__main__':
solution = Solution()
k = 3
p1 = ListNode(1)
p2 = ListNode(2)
p3 = ListNode(3)
p4 = ListNode(4)
p1.next = p2
p2.next = p3
p3.next = p4
ans = solution.getKthFromEnd(p1,k)
print(ans.val)
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof
剑指 Offer 24. 反转链表
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
限制：
0 <= 节点个数 <= 5000
# Definition for singly-linked list.
class ListNode(object):
def __init__(self, x):
self.val = x
self.next = None
class Solution(object):
def reverseList(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
# 说明链表节点不存在或者只有一个节点
if head is None or head.next is None:
return head
pre = None
while head:
# 暂存当前节点的下一个节点信息
temp = head.next
# 反转节点
head.next = pre
# 进行下一个节点
pre = head
head = temp
return pre
if __name__=='__main__':
solution = Solution()
p1 = ListNode(1)
p2 = ListNode(2)
p3 = ListNode(3)
p1.next = p2
p2.next = p3
ans = solution.ReverseList(p1)
print(ans.val)
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof
剑指 Offer 27. 二叉树的镜像
请完成一个函数，输入一个二叉树，该函数输出它的镜像。
例如输入：
镜像输出：
示例 1：
输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]
限制：
0 <= 节点个数 <= 1000
# Definition for a binary tree node.
class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
# 本题的思路就是我要做的事情就是交换所有节点的左孩子和右孩子（前序遍历做的事情是保存所有节点的值），抽象一下就是在原本二叉树的前序遍历保存节点值那一步替换成交换孩子节点，其他的不变。
class Solution(object):
def mirrorTree(self, root):
"""
:type root: TreeNode
:rtype: TreeNode
"""
# 判断节点是否为空
if not root:
return None
# 判断是否是叶节点
if not root.left and not root.right:
return root
# 交换
root.left, root.right = root.right, root.left
# 递归
self.mirrorTree(root.left)
self.mirrorTree(root.right)
return root
if __name__=='__main__':
A1 = TreeNode(4)
A2 = TreeNode(2)
A3 = TreeNode(7)
A4 = TreeNode(1)
A5 = TreeNode(3)
A6 = TreeNode(6)
A7 = TreeNode(9)
A1.left=A2
A1.right=A3
A2.left=A4
A2.right=A5
A3.left=A6
A3.right=A7
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/er-cha-shu-de-jing-xiang-lcof
剑指 Offer 40. 最小的k个数
输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。
示例 1：
输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]
示例 2：
输入：arr = [0,1,2,1], k = 1
输出：[0]
限制：
0 <= k <= arr.length <= 10000
0 <= arr[i] <= 10000
# 解法一：最简单的排序
# 时间复杂度 O(nlogn)
class Solution(object):
def getLeastNumbers(self, arr, k):
"""
:type arr: List[int]
:type k: int
:rtype: List[int]
"""
arr.sort()
return arr[:k]
