【Leetcode】58.左旋转字符串&27.二叉树的镜像

题解均来自Krahets大神！！！

剑指Offer58 左旋转字符串

（字符串元素顺序调整）

# 方法一：字符串切片
class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:    
        # 自己的解法过于麻烦，可以直接切字符串的一段
        # for i in range(n):
        #     s = s + s[0]
        #     s = s[1:]      
        return s[n:] + s [:n] # 直接返回，节省空间
      
# 方法二：列表遍历拼接（如果不允许字符串切片）
class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        res = []
        for i in range(n, len(s)): # 添加第n位及其后的元素
            res.append(s[i])
        for i in range(n): # 添加前n位的元素
            res.append(s[i])
        return ''.join(res) # 用join把列表转回字符串
class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        res = []
        for i in range(n, n + len(s)):
            res.append(s[i % len(s)]) # 用取余代替上面的两步循环确实很秀     
        return ''.join(res)

# 方法三：字符串遍历拼接
class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        res = ""
        for i in range(n, len(s)):
            res += s[i]
        for i in range(n):
            res += s[i]
        return res

class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        res = ""
        for i in range(n, n + len(s)):
            res += s[i % len(s)]
        return res

• 时间与空间复杂度都是$O(N)$

• 效率分析：

  • 方法一：新建两切片字符串，并将两切片拼接为结果字符串，无冗余操作，效率最高。
  • 方法二：
    列表(Python) 是可变对象，每轮遍历拼接字符时，只是向列表尾部添加一个新的字符元素。最终拼接转化为字符串时，系统 仅申请一次内存 。
  • 方法三：在 Python 中，字符串是 “不可变对象” 。因此，每轮遍历拼接字符时，都需要新建一个字符串；因此，系统需申请N次内存 ，数据量较大时效率低下

剑指Offer27 二叉树的镜像

（树结构/树节点）

# 方法一：递归
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
# 输入就已经是树的结构了，列表只是在Leetcode界面方便显示
class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        # 递归   
        if not root:
            return
        root.left, root.right = self.mirrorTree(root.right), self.mirrorTree(root.left) # 直接用Python的平行赋值，省去暂存操作
        return root
# 方法二：辅助栈（或者队列），DFS先序遍历
class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        if not root: return
        stack = [root]
        while stack: # 从根节点出发，从第一次交换开始一次性搞定所有左节点（DFS先序遍历）
            node = stack.pop()
            if node.left: stack.append(node.left)
            if node.right: stack.append(node.right)
            node.left, node.right = node.right, node.left # 无左右节点就是在交换null和null
        return root

• 复杂度分析
  • 时间复杂度 $O(N)$ ： 其中N为二叉树的节点数量，建立二叉树镜像需要遍历树的所有节点，占用$O(N)$ 时间。
  • 空间复杂度$O(N)$ ： 最差情况下（当为满二叉树时），栈 stackstack 最多同时存储N/2个节点，占用$O(N)$额外空间。