剑指offer - 题16~19（合并链表，递归，二叉树子树、镜像，矩阵顺时针打印）

合并两个排序的链表
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
   # 返回合并后列表
   def Merge(self, pHead1, pHead2):
       # write code here
       temp=ListNode(0)
       result=temp
       while pHead1 and pHead2:
           if pHead1.val >= pHead2.val:
               temp.next=pHead2
               pHead2=pHead2.next
           else:
               temp.next=pHead1
               pHead1=pHead1.next
           temp=temp.next
       if pHead1:
           temp.next=pHead1
       if pHead2:
           temp.next=pHead2
       return result.next
   
       # 递归做法
       if not pHead1:
           return pHead2
       if not pHead2:
           return pHead1
       if pHead1.val>=pHead2.val:
           pHead2.next=self.Merge(pHead2.next,pHead1)
           return pHead2
       if pHead2.val>=pHead1.val:
           pHead1.next=self.Merge(pHead1.next,pHead2)
           return pHead1    

树的子结构
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def HasSubtree(self, pRoot1, pRoot2):
        # write code here
        # 思路参考解答区
        result=False
        if pRoot1 and pRoot2:
            if pRoot1.val==pRoot2.val:
                result=self.ChildOrNot(pRoot1,pRoot2)
            if not result:
                result=self.HasSubtree(pRoot1.left,pRoot2)
            if not result:
                result=self.HasSubtree(pRoot1.right,pRoot2)
        return result
    
    def ChildOrNot(self,pRoot1,pRoot2):
    	# 注意两个判断条件的顺序不能颠倒
        if not pRoot2:
            return True
        if not pRoot1:
            return False
        if pRoot1.val!=pRoot2.val:
            return False
        return self.ChildOrNot(pRoot1.left,pRoot2.left) and self.ChildOrNot(pRoot1.right,pRoot2.right)

二叉树的镜像
操作给定的二叉树，将其变换为源二叉树的镜像。
输入描述:
二叉树的镜像定义：源二叉树

    	    8
    	   /  \
    	  6   10
    	 / \  / \
    	5  7 9 11
    	镜像二叉树
    	    8
    	   /  \
    	  10   6
    	 / \  / \
    	11 9 7  5

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        if not root:
            return None
        temp=root.left
        root.left=root.right
        root.right=temp
        if root.left:
            self.Mirror(root.left)
        if root.right:
            self.Mirror(root.right)
        return root

顺时针打印矩阵
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表，需要返回列表
    def printMatrix(self, matrix):
        # write code here
        res = []
        while matrix:
            # 取矩阵第一行并pop
            res += matrix.pop(0)
            # 为了避免[[]]这种情况
            if matrix and matrix[0]:
                # 取当前矩阵第一行
                for row in matrix:
                    # 取当前行最后一个元素并pop
                    res.append(row.pop())
            if matrix:
                # 取当前矩阵最后一行倒序添加并pop
                res += matrix.pop()[::-1]
            if matrix and matrix[0]:
                # 倒序取当前矩阵每一行
                for row in matrix[::-1]:
                    # 添加当前行第一个元素并pop
                    res.append(row.pop(0))
        return res

    # 好玩的思路：每次添加完一整行就将矩阵逆时针旋转
    def printMatrix(self, matrix):
        # write code here
        result = []
        while(matrix):
            result+=matrix.pop(0)
            if not matrix or not matrix[0]:
                break
            matrix = self.turn(matrix)
        return result
    def turn(self,matrix):
        num_r = len(matrix)
        num_c = len(matrix[0])
        newmat = []
        for i in range(num_c):
            newmat2 = []
            for j in range(num_r):
                newmat2.append(matrix[j][i])
            newmat.append(newmat2)
        newmat.reverse()
        return newmat