二叉樹~查找算法~排序算法

二叉樹

　　二叉樹是一種樹形結構，其中包含一個根節點和左右葉子節點，一個根節點下面只能有兩個葉子節點（所謂二叉）

　　二叉樹分為 普通二叉樹和排序二叉樹

　　一個二叉樹中又包含多個子樹，子樹又分為完整的子樹和非完整的子樹，每個子樹的根節點可以作為另一個子樹的葉子節點，每個葉子節點又可以作為另一個子樹的根節點

構建一個二叉樹

 

class Node:
    #構建節點
    def __init__(self,item):
        self.item = item
        self.right = None
        self.left = None
        
class Tree:
    #構建二叉樹
    def __init__(self):
        self.root = None
        
    #給二叉樹添加節點
    def insert(self,item):
        node = Node(item)
        if self.root == None:
            self.root = node
            return
        cur = self.root
        queue = [cur]
        while True:
            leaf = queue.pop(0)
            if leaf.left == None:
                leaf.left = node
                return
            else:
                queue.append(leaf)
                
            if leaf .right == None:
                leaf.right = node
                return
            else:
                queue.append(leaf)

 

二叉樹的遍歷

廣度遍歷（橫向）

    #廣度遍歷
    def travel(self):
        cur = self.root
        queue = [cur]
        while queue:
            leaf = queue.pop(0)
            print(leaf.item)
            if leaf.left:
                queue.append(leaf.left)
            if leaf.right:
                queue.append(leaf.right)

深度遍歷（縱向） 注意：縱向遍歷一定是作用於每個子樹當中

前序遍歷：根左右

def forward(self,root):
        if root == None:
            return
        print(root.item)
        self.forward(root.left)
        self.forward(root.right)

中序遍歷：左根右 中序遍歷排序二叉樹時得到的結果肯定是有序的

    def middle(self,root):
        if root == None:
            return
        self.middle(root.left)
        print(root.item)
        self.middle(root.right)

后續遍歷：左右根

    def back(self,root):
        if root == None:
            return
        self.back(root.left)
        self.back(root.right)
        print(root.item)

排序二叉樹

　　排序二叉樹即左葉子節點都要小於根節點，右葉子節點都要大於根節點，

構建一個排序二叉樹

class Node:
    def __init__(self,item):
        self.item = item
        self.left = None
        self.right = None

class SortTree:
    def __init__(self):
        self.root = None
        
    def insert(self,item):
        node = Node(item)
        if self.root == None:
            self.root = node
            return
        cur = self.root
        while True:
            #新節點插入到根節點的左側
            if node.item < cur.item:
                if cur.left == None:
                    cur.left = node
                    return
                else:
                    cur = cur.left
            #新節點插入到根節點的右側
            if node.item > cur.item:
                if cur.right == None:
                    cur.right = node
                    return
                else:
                    cur = cur.right

 

冒泡排序

#冒泡排序
def sort(alist):
    for i in range(0,len(alist)-1):
        for j in range(0,len(alist)-1-i):
            if alist[j] > alist[j+1]:
                alist[j],alist[j+1] = alist[j+1],alist[j]
    return alist

選擇排序

#選擇排序
def sort(alist):
    for j in range(0,len(alist)-1):
        max_index = j
        for i in range(0,len(alist)-1-j):
            if alist[i] < alist[i+1]:
                max_index = i+1
        alist[-(j+1)],alist[max_index] = alist[max_index],alist[-(j+1)]
    return alist

插入排序

　　插入排序把數列分成有序和無序數列兩個部分，其核心是將無序數列中的每個元素插入到有序數列的正確位置，起始有序數列元素個數為1,。

#插入排序
def sort(alist):
    #i可既能表示元素的下標，也可以表示有序數列的個數
    for i in range(1,len(alist)):
        while i > 0:
            if alist[i] < alist[i-1]:
                alist[i],alist[i-1] = alist[i-1],alist[i]
                i -= 1
            else:
                break
            
    return alist

希爾排序

　　希爾排序可以看成是按照增量（數列長度//2）分組進行插入排序

　　插入排序也可以看成是增量為1的希爾排序

#希爾排序
def sort(alist):
    gap = len(alist)//2
    while gap > 0:
        for i in range(gap,len(alist)):
            while i > 0:
                if alist[i] < alist[i-gap]:
                    alist[i],alist[i-gap] = alist[i-gap],alist[i]
                    i -= 1
                else:
                    break
        gap = gap // 2
    return alist

快速排序

　　簡單的說一下快速排序，快速排序就是找一個基准值，將數列中的數據每循環一遍后達到的效果為基准值左側的都是比基准值小的數值，基准值右側的都是比基准值大的數值，然后再利用迭代對基准值左右兩側的數列分別進行快速排序，最后得到一個有序數列。

#快速排序
def sort(alist,start,end):
    
    low = start
    high = end
    if low > high:
        return alist
    
    mid = alist[start]
    print(mid)
    
    while low < high:
        while low < high:
            if alist[high] < mid:
                alist[low] = alist[high]
                break
            else:
                high = high -1
        while low < high:
            if alist[low] > mid:
                alist[high] = alist[low]
                break
            else:
                low = low + 1
    if low == high:
        alist[high] = mid
    #對左側數列進行排序
    sort(alist,start,low-1)
    #對右側數列進行排序
    sort(alist,high+1,end)
    
    return alist