數據結構+算法 次日 排序算法 二叉樹 排序二叉樹

順序查找

查找原理:

從列表中的第一個元素開始,咱們按照基本的元素排序,簡單的從一個元素移動到另外一個元素,直到找到咱們要找的元素或是遍歷完整個列表.

實例代碼:

def search(item,alist):
    find=False
    length=len(alist)

    for i in range(length):
        if alist[i] == item:
            find=True

    return find

對有序列表進行循環會提高查找的效率:

def search(alist,item):
    find=False
    length=len(alist)
    pos=0
    stop=False
    while pos <=length and not stop:
        if alist[pos] == item
            find=True
            break
        elif alist[pos]>item:
            stop = True
        pos+=1
    
    return find

二分法查找(注意 : 二分法查找查找的對象必須是有序的)

 概況:

咱們在以前在進行有序列表的查找時,發現若是咱們查找的對象在列表的最後一個,咱們查找一次以後,還有n-1次才能查找到,二分法查找則是將列表的最中間的元素找到,而後跟咱們找的值進行比較,若是比這個數大,則將中間這個數前面的全部數排除掉,在將中間這個值做爲新列表的起始值.這樣極大地提高了咱們的查找效率,固然只有在列表的值很大的時候才能發現出效果.

 實例代碼:

def search(alist,item):
    first_index=0
    last_index=len(alist-1)
    find_status=False

    while first_index<=last_index and not find_status:
        mid_index=(first_index+last_index)//2

        if alist[mid_index] > item:
            last_index =mid_index-1

        elif alist[mid_index] < item:
            first_index=mid_index+1
        else:
            find=True
    
    return find

二叉樹

結構:
    根節點
    葉子節點
       - 左葉子節點
       - 右葉子節點
    子樹

二叉樹中有節點和樹模型,這裏咱們要分別寫節點和樹模型.

節點:

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

空樹模型:

class Tree:
    def __init__(self):
        self.root=None
    
    #往樹中添加數據
    def add(self,item):
　　　　 #實例化一個節點
        node=Node(item)
        #若是樹是空樹,直接將節點添加到樹根
        if self.root == None:
            self.root=node    
            return 
        queue=[self.root]

        #從隊列中取值,而且判斷直到return或者隊列爲空爲止
        while queue:
            cur=queue.pop(0)
            if self.left == None:
                self.left = node
                return
            else:
                queue.append(cur.left)
            if self.right == None:
                self.right = node
                return
            else:
                queue.append(cur.right)
    
    #廣度優先遍歷
    def guangdu(self):
        queue=[self.root]
        while queue:
            cur = queue.pop(0)
            if cur.left is not None:
                queue.append(cur.left)
            elif cur.right is not None:
                queue.append(cur.right)

    #深度優先遍歷(分爲三種形式,根左右,左根右,左右根)
    def root_left_right(self,root):
        if root == None:
            return
        print(root.item,end='')
        root_left_right(root.left)
        root_left_right(root.right)

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

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

遍歷二叉樹有兩種方法: 廣度優先遍歷和深度優先遍歷

廣度優先遍歷: 從根節點開始一層一層的開始遍歷.

深度優先遍歷:從根節點開始,往下找,若是左節點下面還有節點,繼續往下找,直到找到最後一個節點爲止(這裏深度優先遍歷分爲三種,根左右,左根右,左右根)

 根左右(前序)

左根右(中序,中序是能夠對列表中的元素進行排序的)

 

左右根(後序)

排序二叉樹

在插入數據的時候須要一個準則,好比比根節點大的數插入到右邊,比根節點小的數插入到左邊.

class Node:
    def __init__(self,item):
        self.item=item
        self.left=None
        self.right=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
        while True:
            if item > cur.item:
                if cur.right == None:
                    cur.right = node
                    reutrn 
                cur =cur.right
            else:
                if cur.left == None:
                    cur.left =node
                    return
                cur =cur.left

排序算法

這裏咱們介紹5中排序規則
　　- 冒泡排序
　　- 選擇排序
　　- 插入排序
　　- 希爾排序
　　- 快速排序(快排)

冒泡排序(若是前面那個數比後面那個數大,就互換位置)

def maopao(alist):
    length=len(alist)
　　 #若是不進行此次循環,列表仍是無序的,只是將最大值放到了最後的位置
    for j in range(length-1):
　　　　　#此次循環是爲了將最大值放到最後
        for i in range(length-1-j):
            if alist[i]>alist[i+1]:
                alist[i],alist[i+1] = alist[i+1],alist[i]
    return alist

選擇排序(先指定第一個索引位置的數字爲最大數字,而後從第二個數開始循環,若是這個數比第一個大,那麼將最大索引改成新數的索引,直到循環玩這個列表,在將最大數的索引與列表最後一個索引互換便可)

def xuanze(alist):
    length=len(alist)
　　 #若是不進行這個for循環,沒法將每次循環獲得的最大值放到最後一個位置
    for j in range(length-1,0,-1):
        max_index=0
        for i in range(1,j+1):
            if alist[i] > alist[max_index]:
                max_index = i

        alist[max_index],alist[j] = alist[j],alist[max_length]

    return alist

插入排序(假設前面第一個數爲一個列表中的第一個元素,從第二個數開始循環,若是比他小,就互換位置,而後再次循環,直到循環到第一個索引爲止)

def charu(alist):
    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

希爾排序(其實能夠理解成優化版的插入排序,至關於分了個組)

 

那麼有人會問了,爲何我不能直接用插入排序呢,這不是閒的嘛.你想呀,咱們這個插入排序是否是要循環好屢次呢,若是咱們有100萬條數據,咱們要循環100萬次呢,而希爾排序會幫我縮短查找的次數,官方一點就是希爾排序的時間複雜度是O(n),而插入排序的時間複雜度爲O(n²).因此希爾排序比直接插入排序要省時.

def sort(alist):
    gap = len(alist) // 2
    while gap >= 1:
        for j in range(gap,len(alist)):
            i = j
            while i>0:
                if alist[i] < alist[i-gap]:
                    alist[i],alist[i-gap] = alist[i-gap],alist[i]
                    i = i-gap
                else:
                    break
        
        #縮減增量
        gap = gap//2
    return alist

快速排序

def sort(alist,start,end):
    low = start
    high = end
    mid = alist[low]
    
    if low >= high:
        return
    
    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
    alist[low] = mid
    
    #mid左側的子列表
    sort(alist,start,low-1)
    #mid右側的子列表
    sort(alist,low+1,end)
    
    return alist