【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 ) O(N) 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 ) O(N) O(N) : 其中N为二叉树的节点数量,建立二叉树镜像需要遍历树的所有节点,占用 O ( N ) O(N) O(N) 时间。
    • 空间复杂度 O ( N ) O(N) O(N) : 最差情况下(当为满二叉树时),栈 stackstack 最多同时存储N/2个节点,占用 O ( N ) O(N) O(N)额外空间。
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 1024 设计师:白松林 返回首页