劍指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()