剑指offer python版 part2

1.输入两棵二叉树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
        res = False
        if (pRoot1 != None and pRoot2 != None):
            if pRoot1.val == pRoot2.val:
                res = self.dfs(pRoot1,pRoot2)
            if res != True:
                res = self.HasSubtree(pRoot1.left,pRoot2)
            if res!= True:
                res = self.HasSubtree(pRoot1.right ,pRoot2)

        return res
    
    def dfs(self,p1,p2):
        if  p2 == None:
            return True
        if p1 == None:
            return False
        if p1.val != p2.val:
            return False
        return self.dfs(p1.left,p2.left) and self.dfs(p1.right,p2.right)

2.操作给定的二叉树，将其变换为源二叉树的镜像。

# -*- 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 root == None:
            return None
        root.left ,root.right = self.Mirror(root.right),self.Mirror(root.left)
        return root

3.从上往下打印出二叉树的每个节点，同层节点从左至右打印。

# -*- coding:utf-8 -*-
#二叉树的层次遍历  用队列保存节点
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回从上到下每个节点值列表，例：[1,2,3]
    def PrintFromTopToBottom(self, root):
        # write code here
        if root == None:
            return []
        lstNode = [root]
        lstRes = []
        while (lstNode):
            curNode = lstNode.pop(0)
            lstRes.append(curNode.val)
            if curNode.left != None:
                lstNode.append(curNode.left)
            if curNode.right != None:
                lstNode.append(curNode.right)
        return lstRes

4.输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。

# -*- coding:utf-8 -*-
# class RandomListNode:
#     def __init__(self, x):
#         self.label = x
#         self.next = None
#         self.random = None
class Solution:
    # 返回 RandomListNode
    def Clone(self, pHead):
        # write code here
        if pHead == None:
            return None
        curNode = pHead
        
        while(curNode != None):
            temp = RandomListNode(curNode.label)
            nextNode = curNode.next
            curNode.next = temp
            temp.next = nextNode
            curNode = curNode.next.next
        
        curNode = pHead
        while(curNode != None):
            if curNode.random != None:
                curNode.next.random = curNode.random.next
            else:
                curNode.next.random = None
            curNode = curNode.next.next
        
        curNode = pHead
        newHead = pHead.next
        while(curNode.next != None):
            nextNode = curNode.next
            curNode.next = curNode.next.next
            curNode = nextNode
        return newHead
            

5.输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323

# -*- coding:utf-8 -*-
# -*- coding:utf-8 -*-
#数组组合最小数
class Solution:
    def sortFunc(self,n1,n2):
        #判断小于
        n1 = str(n1)
        n2 = str(n2)
        if (int(n1+n2) < int(n2+n1)):
            return True
        else:
            return False
    def QuickSort(self,numbers):
        low = 1
        hig = len(numbers) - 1
        if hig <1:
            return numbers
        flag = numbers[0]
        while(low < hig):
            if (self.sortFunc(numbers[hig],flag)):
                while(low <hig):
                    if(self.sortFunc(numbers[low],flag) ==True):
                        low += 1
                    else:
                        numbers[low],numbers[hig] = numbers[hig],numbers[low]
                        break
            else:
                hig -= 1
        if (self.sortFunc(numbers[low],flag) == False):
            return self.QuickSort(numbers[1:low]) + [flag] + self.QuickSort(numbers[low:])
        else:
            return self.QuickSort(numbers[1:low+1]) + [flag] + self.QuickSort(numbers[low+1:])
    
    def PrintMinNumber(self, numbers):
        # write code here
        if (len(numbers)) == 0:
            return ""
        numbers = self.QuickSort(numbers)
        res = ""
        for item in numbers:
            res += str(item)
        return int(res)

6.输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回二维列表，内部每个列表表示找到的路径
    def __init__(self):
        self.ans = []
        self.path = []
    def FindPath(self, root, expectNumber):
        # write code here
        self.dfs(root,expectNumber)
        return self.ans
    def dfs(self,root,expectNumber):
        if root == None:
            return None
        expectNumber -= root.val
        self.path.append(root.val)
        #判断是否为叶子节点，且是否满足和的要求
        if root.left == None and root.right == None and expectNumber == 0:
            temp = self.path[:]
            self.ans.append(temp)
        self.dfs(root.left,expectNumber)
        self.dfs(root.right,expectNumber)
        #往回退时，将path中判断过的节点逐个去除
        self.path.pop()