力扣刷题 day07 ：09-06

1.爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

方法一：动态规划 

#方法一：动态规划
def climbStairs(n):
    a,b=1,1
    for i in range(n):
        a,b=b,a+b     #典型的斐波拉契数列 1 1 2 3....f(n)=f(n-1)+f(n-2)
    return a

 2.删除排序链表中的重复元素

给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。

 

方法一：一次遍历，利用两个指针prev和cur

#方法一：一次遍历，利用两个指针prev和cur
def deleteDuplicates(head):
    if not head:           #单独判断特殊情况
        return None
    prev,cur=head,head.next   #两个指针
    while cur:
        if prev.val == cur.val: #相等则删除cur
            prev.next=cur.next  #prev的下一个节点跳过cur
        else:
            prev=cur   #不等则prev跳到cur
        cur=cur.next   #cur指向下一个节点
    return head

方法二：递归方法 

#方法二：递归方法
def deleteDuplicates(head):
    if not head or not head.next:  #递归终止条件
        return head
    if head.val!=head.next.val:      
        head.next=deleteDuplicates(head.next) #不等则后面的节点要进行去重，进行递归,找到head的下一个节点
    else:
        move=head.next #move指针进行移动
        while move.next and head.val==move.next.val: #找到最后一个与头节点指向的值相等的节点
            move=move.next   #找到则进行删除
        return deleteDuplicates(move)     #move之后的链表进行去重
    return head

 3.合并两个有序数组

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

方法一：倒序双指针法

#方法一：倒序双指针法
def merge(nums1,m,nums2,n):
    p1,p2,p=m-1,n-1,m+n-1    #初始化三个指针，分别指向尾部
    while p2>=0: #还有要合并的
        if p1>=0 and nums1[p1]>nums2[p2]:
            nums1[p]=nums1[p1] #放入空位
            p1-=1  #指针前移
        else:
            nums1[p]=nums2[p2]  #包括了p2<0的情况
            p2 -= 1
        p-=1  #空位前移
merge(nums1 = [1], m = 1, nums2 = [], n = 0)

 4.二叉树的中序遍历

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

方法一：递归法

#方法一:递归法
def inOrder(root,res):  #中序遍历，左子树，根节点，右子树
    if not root:   #如果为none则返回
        return 
    inOrder(root.left,res)  #先遍历左子树
    res.append(root.val)  #添加根节点
    inOrder(root.right, res) #后遍历右子树
def inorderTraversal(root):
    res=[]
    inOrder(root, res)
    return res

方法二：迭代法 

#方法二：迭代法
def inorderTraversal(root):
    stack=[]
    p=root #指针
    res=[]
    while stack or p:
        while p:  #将左子树压入栈中
            stack.append(p)
            p=p.left
        p=stack.pop()  #栈顶出栈
        res.append(p.val) #获取栈顶元素
        p=p.right  #遍历右子树
    return res

5.相同的树

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

方法一：递归法

#方法一：递归法
def isSameTree(p,q):
    if p==None and q==None:
        return True       #两棵树都是空
    if (p==None and q!=None) or (q==None and p!=None):
        return False   #一棵树为空
    if p.val!=q.val:
        return False   #根节点不同
    leftTree=isSameTree(p.left,q.left) #比较左右子树是否相同      
    rightTree=isSameTree(p.right,q.right)
    isSame=leftTree and rightTree  #左右子树都相同的时候才会返回true
    return isSame

 方法二：迭代法

#方法二：迭代法
def isSameTree(p,q):
    queue=[p,q]  #初始化队列
    while queue:
        pN=queue.pop(0) #从队列中取出两个节点
        qN = queue.pop(0)
        if (qN==None and pN !=None) or (pN==None and qN !=None):
            return False
        if qN==None and pN==None:
            continue  #如果当前节点为空则继续循环
        if pN.val!=qN.val:
            return False  #当前节点值不等
        queue.append(pN.left)
        queue.append(qN.left)  #左右节点依次入队列
        queue.append(pN.right)
        queue.append(qN.right)
    return True