leetcode(5)

234. 回文链表

链表查询时间复杂度为o(n), 数组查询时间复杂度为o(1)
要想时间复杂度为o(n), 遍历一遍链表就是o(n），将链表放到数组中看是否是回文，加起来还是o（n）

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def isPalindrome(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        vals=[]
        cur=head
        while cur:
            vals.append(cur.val)
            cur=cur.next
        return vals==vals[::-1]
            

104. 二叉树的最大深度

递归：

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root is None:
            return 0
        else:
            left_height=self.maxDepth(root.left)
            right_height=self.maxDepth(root.right)
            return max(left_height,right_height)+1

非递归，可使用层序遍历：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        queue,res=[root],0
        while queue:
            res+=1
            tmp=[]
            for node in queue:
                if node.left:
                    tmp.append(node.left)
                if node.right:
                    tmp.append(node.right)
                queue=tmp
        return res

226. 翻转二叉树

递归：

class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if root is None:
            return None
        root.left,root.right=self.invertTree(root.right),self.invertTree(root.left)
        return root

非递归，用栈：

class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if root is None:
            return None
        stack=[root]
        while stack:
            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
        return root

102. 二叉树的层序遍历

层次遍历类似广度优先搜索BFS，可以采用队列实现
每次将节点放入队列中，计算队列长度，队列头弹出当前队列节点，并依次将节点的左右节点放入队列中。

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if root is None:
            return None
        res=[]
        queue=[root]
        while queue:
            size=len(queue)
            tmp=[]
            for _ in range(size):
                r=queue.pop(0)
                tmp.append(r.val)
                if r.left:
                    queue.append(r.left)
                if r.right:
                    queue.append(r.right)
            
            res.append(tmp)
        return res
        

101. 对称二叉树

递归：

class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if root is None:
            return True
        def check(left,right):
            if left is None and right is None:
                return True
            if left is None or right is None:
                return False
            if left.val!=right.val:
                return False
            return check(left.left,right.right) and check(left.right,right.left)
        return check(root.left,root.right)

非递归：
层次遍历，用队列

class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if root is None or (root.left is None and root.right is None):
            return True
        queue=[root.left,root.right]
        while queue:
            left=queue.pop(0)
            right=queue.pop(0)
            if left is None and right is None:
                continue
            if left is None or right is None:
                return False
            if left.val !=right.val:
                return False
            queue.append(left.left)
            queue.append(right.right)
            queue.append(left.right)
            queue.append(right.left)
        return True

543. 二叉树的直径

二叉树的直径可能不会经过根节点，不能直接将根的左子树最大高度+右子树最大高度，还要比较最大直径和当前直径

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def diameterOfBinaryTree(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root is None:
            return 0

        def max_height(node):
            if node is None:
                return 0
            left_height=max_height(node.left)
            right_height=max_height(node.right)
            self.diameter = max(self.diameter, left_height + right_height)
            return max(left_height,right_height)+1

        
        self.diameter = 0
        # 调用递归函数计算树的高度
        max_height(root)
        # 返回直径
        return self.diameter