day12 數據結構+算法

day12 數據結構+算法

二叉樹

class Node():
    def __init__(self,item):
        self.item = item
        self.left = None
        self.right = None
class Tree():
    def __init__(self):
        self.root = None
    def addNode(self,item):
        node = Node(item)
        if self.root == None:#若是樹中沒有節點,把第一個的節點給root
            self.root = node 
            return 
        cur = self.root #不改變root節點.賦值
        while 1 :
            q = [cur]  # 將節點加到列表中,而後在pop出來,左右爲空,添加節點,不爲空,添加到列表中繼續判斷
#  要賦值,不然每次都要pop,pop太多值了,一次.
#             if q.pop(0).left == None :#若是左節點沒有
#                 q.pop(0).left = node #給左節點賦值
#                 return #退出函數
#             else:....
 
            n = pop(0)
            if n.left == None :#若是左節點沒有
                n.left = node #給左節點賦值
                return #退出函數
            else:
                q.append(n.left)#若是左節點有,加到列表中判斷
            if n.right == None :
                n.right = node 
                return 
            else:
                q.append(n.right)

廣度排序

前序 (根左右)

寫出一個來,而後套到別的樹

有序的深度排序

中序

class SortTree():
    def __init__(self):
        self.root = None 
    def midTravel(self,root):
        if root = None 
            return 
        # 左根右
        self.midTravel(root.left) # 遞歸, 循環直到return 
        print(root.item)
        self.midTravel(root.right)

    def insertNode(self,item):
        node = Node(item)
        cur = self.root 
        # 數爲空
        if self.root == None:
            self.root = node 
            return 
        # 樹爲非空 
        while True: 
            if cur.left > node.item :
                cur.left = node 
                break 
            else:
                cur = cur.left 
                
            if cur.right > node.item :
                cur.right = node 
                break 
            else:
                cur = cur.right

單鏈表寫出以後,雙鏈表也能夠,循環列表

排序二叉樹

寫出來,寫樹的高度,什麼均可以了.

深度排序:

中序有用, 也沒有排序, 自動排序

排序算法

二分查找

• 有序列表對於咱們的實現搜索是頗有用的。在順序查找中，當咱們與第一個元素進行比較時，若是第一個元素不是咱們要查找的，則最多還有 n-1 個元素須要進行比較。 二分查找則是從中間元素開始，而不是按順序查找列表。 若是該元素是咱們正在尋找的元素，咱們就完成了查找。 若是它不是，咱們能夠使用列表的有序性質來消除剩餘元素的一半。若是咱們正在查找的元素大於中間元素，就能夠消除中間元素以及比中間元素小的一半元素。若是該元素在列表中，確定在大的那半部分。而後咱們能夠用大的半部分重複該過程，繼續從中間元素開始，將其與咱們正在尋找的內容進行比較。

low = 0 
high = len() -1 
mid = (low+high)//2
while  low <= high:
​   if items[mid]>item : low = ...
​   if < : high = ...
​   else : find = T
return find 


# 基於有序  減半  速度

def search(alist,item):
    find = False
    low = 0
    high = len(alist)-1
    
    while low <= high:
        mid = (low+high) // 2 #中心位置的元素下標（切割點）
        if alist[mid] < item:
            low = mid + 1
        elif alist[mid] > item:
            high = mid - 1
        else:#alist[mid] == item
            find = True
            break
        
    return find
alist = [1,2]
print(search(alist,22))

冒泡排序

• 1.將原始列表中的最大值找出且放置在列表最右側(將元素兩兩比較，將數值大的數逐步向後移動)
• 2.重複執行步驟1

#將原始列表中的最大值找出且放置在列表最右側(將元素兩兩比較，將數值大的數逐步向後移動)
def sort(alist):
    for i in range(len(alist)-1):
        if alist[i] > alist[i+1]:
            alist[i],alist[i+1] = alist[i+1],alist[i]
    return alist

def sort(alist):
    for j in range(len(alist)-1):
        #交換
        for i in range(len(alist)-1-j):
            if alist[i] > alist[i+1]:
                alist[i],alist[i+1] = alist[i+1],alist[i]
            
            
    return alist

alist = [3,6,1,4,8,2]
print(sort(alist))

----->[1, 2, 3, 4, 6, 8]

選擇排序

將最大值一次找出, 放在列表最右

#將列表中的最大值的下標找到
def sort(alist):
    max_index = 0 #最大值的下標
    for i in range(1,len(alist)):
        if alist[max_index] < alist[i]:
            max_index = i
    print(max_index)

#將列表中的最大值一次找出，放置在列表最右側
def sort(alist):
    max_index = 0 #最大值的下標
    for i in range(1,len(alist)):
        if alist[max_index] < alist[i]:
            max_index = i
    alist[max_index],alist[len(alist)-1] = alist[len(alist)-1],alist[max_index]
    
    return alist

def sort(alist):
    for j in range(len(alist),1,-1):
        max_index = 0 #最大值的下標
        for i in range(1,j):  #len(alist)  == > j
            if alist[max_index] < alist[i]:
                max_index = i
        alist[max_index],alist[j-1] = alist[j-1],alist[max_index]
    
    return alist

alist = [3,6,1,4,8,2]
sort(alist)

---->[1, 2, 3, 4, 6, 8]

相比來講,交換的次數少了, 在第一循環內部, 第二循環外部

排序二叉樹

class SortTree():
    def __init__(self):
        self.root = None
        
    def midTravel(self,root):
        if root == None:
            return
        #左根右
        self.midTravel(root.left)
        print(root.item)
        self.midTravel(root.right)
        
    def insertNode(self,item):
        node = Node(item)
        cur = self.root
        #樹爲空
        if self.root == None:
            self.root = node
            return
        #樹爲非空
        while True:
            if cur.item > node.item:
                if cur.left == None:
                    cur.left = node
                    break
                else:
                    cur = cur.left
            else:
                if cur.right == None:
                    cur.right = node
                    break
                else:
                    cur = cur.right

t = SortTree()
t.insertNode(3)
t.insertNode(8)
t.insertNode(3)
t.insertNode(1)
t.insertNode(1)

t.midTravel(t.root)

---->

1
1
3
3
8

快排

def sort(alist,start,end):
    low = start
    high = end

    
    #結束遞歸的條件
    if low > high:
        return
    mid = alist[low]
    
    while low < high:
        while low < high:
            if alist[high] > mid:
                high -= 1
            else:
                alist[low] = alist[high]
                break
        while low < high:
            if alist[low] < mid:
                low += 1
            else:
                alist[high] = alist[low]
                break
                
#         if low == high:
    alist[low] = mid
    
    sort(alist,low+1,end) #將基準右側的子列表進行遞歸操做
    sort(alist,start,high-1)
    return alist