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