二叉樹基礎:
- 樹的定義:樹(英語:Tree)是一種無向圖(undirected graph),其中任意兩個頂點間存在唯一一條路徑。或者說,只要沒有迴路的連通圖就是樹。
- 二叉樹(英語:Binary tree)是每個節點最多隻有兩個分支(不存在分支度大於2的節點)的樹結構。通常分支被稱作“左子樹”和“右子樹”。二叉樹的分支具有左右次序,不能顛倒。
- 完全二叉樹:葉節點只能出現在最下層和次下層,並且最下面一層的結點都集中在該層最左邊的若干位置的二叉樹。
- 平衡二叉樹:它是一棵空樹或它的左右兩個子樹的高度差的絕對值不超過1,並且左右兩個子樹都是一棵平衡二叉樹。
- 樹的應用:
快速數據檢索:①STL的紅黑樹;②數據庫的B+樹;
文檔結構組織:DOM
人工智能:決策樹
遊戲:通過構造空間樹實現快速碰撞檢測(https://www.zhihu.com/question/25111128)
區塊鏈的默克爾樹
常用算法:
- 遞歸:樹的深度優先遍歷(以前序遍歷爲例) 模擬遍歷如下二叉樹:
- 隊列:樹的廣度優先遍歷(分層遍歷):
leetcode例題:
94.題目:給定一個二叉樹,返回它的中序 遍歷。
示例:
輸入: [1,null,2,3]
1
\
2
/
3
輸出: [1,3,2]
解法:
一、遞歸法:
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def __init__(self):
self.ret=[]
def inorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
if root is not None:
self.inorderTraversal(root.left)
self.ret.append(root.val)
self.inorderTraversal(root.right)
return self.ret
二、非遞歸:
def loopVersion(self, root): # 非遞歸版本
ret, stack = [], []
#如果root不爲空或者堆棧有元素:
while root or stack:
#1.root不爲空,root壓入堆棧
while root:
stack.append(root)
#2.root=root.left
root = root.left
#3.回到1
#4.如果堆棧有元素
if stack:
#5.彈出元素,加入返回隊列
root = stack.pop()
ret.append(root.val)
#6.root=root.left繼續while循環
root = root.right
return ret
106.題目:根據一棵樹的中序遍歷與後序遍歷構造二叉樹。
注意:
你可以假設樹中沒有重複的元素。
例如,給出
中序遍歷 inorder = [9,3,15,20,7]
後序遍歷 postorder = [9,15,7,20,3]
返回如下的二叉樹:
3
/ \
9 20
/ \
15 7
解法:
class Solution:
"""
@param inorder : A list of integers that inorder traversal of a tree
@param postorder : A list of integers that postorder traversal of a tree
@return : Root of a tree
"""
def buildTree(self, inorder, postorder):
# write your code here
return self._buildTree(inorder, 0, len(inorder), postorder, 0, len(postorder))
def _buildTree(self, inorder, in_start, in_end, postorder, post_start, post_end):
if in_start >= in_end:
return None
i = in_start
while i < in_end:
if inorder[i] == postorder[post_end -1]: # 找到根節點
break
i += 1
root = TreeNode(inorder[i])
left_len = i - in_start # 左子樹元素數量
root.left = self._buildTree(inorder, in_start, i, postorder, post_start, post_start + left_len)
root.right = self._buildTree(inorder, i + 1, in_end, postorder, post_start + left_len, post_end - 1)
示例:
輸入:
4
/ \
2 7
/ \ / \
1 3 6 9
輸出:
4
/ \
7 2
/ \ / \
9 6 3 1
解法:遞歸法與中序遍歷相似
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def invertTree(self, root):
"""
:type root: TreeNode
:rtype: TreeNode
"""
if root is not None:
root.left,root.right = root.right,root.left
self.invertTree(root.left)
self.invertTree(root.right)
return root
堆的基礎知識:
- 堆的定義(from Wiki):堆的實現通過構造二叉堆(binary heap),實爲二叉樹的一種;由於其應用的普遍性,當不加限定時,均指該數據結構的這種實現。這種數據結構具有以下性質:
①任意節點小於(或大於)它的所有後裔,最小元或最大元)在堆的根上(堆序性)。
②堆總是一棵完全樹。即除了最底層,其他層的節點都被元素填滿,且最底層儘可能地從左到右填入。 - 建堆的過程:
- 建堆的複雜度分析:
①N個節點的堆高度最大爲h=logN,最下面一層非葉子節點最多調整1次,倒數第2層最多2次,…依此類推,根節點最多需要h次。
②最下面一層子節點共有2^(h-1)個,倒數第2層有2^(h-2)個,…依此類推,根節點有2^(h-h)個1個。
③所以總的時間複雜度爲1^(h-1) + 2*2^(h-2) + (h-1)*2 + h,得到結果爲N*2 –2 –log(N),所以時間複雜度O(n)。 - 堆的應用:
leetcode例題:
題目:堆化
給出一個整數數組,堆化操作就是把它變成一個最小堆數組。
對於堆數組A,A[0]是堆的根,並對於每個A[i],A [i * 2 + 1]是A[i]的左兒子並且A[i * 2 + 2]是A[i]的右兒子。
您在真實的面試中是否遇到過這個題? 是
題目糾錯
說明
什麼是堆?
- 堆是一種數據結構,它通常有三種方法:push, pop 和 top。其中,“push”添加新的元素進入堆,“pop”刪除堆中最小/最大元素,“top”返回堆中最小/最大元素。
什麼是堆化?
- 把一個無序整數數組變成一個堆數組。如果是最小堆,每個元素A[i],我們將得到A[i * 2 + 1] >= A[i]和A[i * 2 + 2] >= A[i]
如果有很多種堆化的結果?
- 返回其中任何一個。
樣例
給出 [3,2,1,4,5]
,返回[1,2,3,4,5]
或者任何一個合法的堆數組
挑戰
O(n)的時間複雜度完成堆化
解法:
class Solution:
"""
@param: A: Given an integer array
@return: nothing
"""
def heapify(self, A):
# write your code here
for i in range(int((len(A)-1)/2),-1,-1):
while i < len(A):
left,right = i*2+1,i*2+2
min_pos = i
if (left<len(A)) and (A[left]<A[min_pos]):
min_pos=left
if (right<len(A)) and (A[right]<A[min_pos]):
min_pos=right
if min_pos!=i:
A[i],A[min_pos]=A[min_pos],A[i]
i = min_pos
else:
break
合併 k 個排序鏈表,返回合併後的排序鏈表。請分析和描述算法的複雜度。
示例:
輸入:
[
1->4->5,
1->3->4,
2->6
]
輸出: 1->1->2->3->4->4->5->6
解法:這是別人寫的一個解法,我自己沒做出來
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
k=len(lists)
if k==0:
return []
if k==1:
return lists[0]
combine_list=lists[0]
aim_list=ListNode(0)
for i in range(1,k):
pointer_aim_list=aim_list
list_1=combine_list
#list_2=lists[i]
pointer_list_2=lists[i]
pointer_list_1=list_1
while pointer_list_1!=None or pointer_list_2!=None:
if pointer_list_1==None:
pointer_aim_list.next=pointer_list_2
break
if pointer_list_2==None:
pointer_aim_list.next=pointer_list_1
break
if pointer_list_1.val<=pointer_list_2.val:
pointer_aim_list.next=pointer_list_1
pointer_list_1=pointer_list_1.next
pointer_aim_list=pointer_aim_list.next
else:
pointer_aim_list.next=pointer_list_2
pointer_list_2=pointer_list_2.next
pointer_aim_list=pointer_aim_list.next
combine_list=aim_list.next
#aim_list=aim_list.next
return aim_list.next
這是另一種,速度更快
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def less(self, a, b):
if a.val < b.val:
return a
else:
return b
def mergeTwoLists(self, l1, l2):
l3 = ListNode(0)
rl3 = l3
while l1 or l2:
if not l1 or not l2:
l3.next = l1 if l1 else l2
break
l3.next = self.less(l1, l2)
if l3.next == l1:
l1 = l1.next
else:
l2 = l2.next
l3 = l3.next
return rl3.next
def mergeKLists(self, lists):
half = int(len(lists)/2)
left = lists[0:half]
right = lists[half:]
if 0 <= len(left) <= 1 and 0 <= len(right) <= 1:
return self.mergeTwoLists(left[0] if left else [], right[0] if right else [])
return self.mergeTwoLists(self.mergeKLists(left), self.mergeKLists(right))
To be continue......