數據結構 --- 03.查找, 二叉樹

一.查找

　　1.順序查找(列表無序)

順序查找原理剖析：
　　從列表中的第一個元素開始，咱們按照基本的順序排序，簡單地從一個元素移動到另外一個元素，
　　直到找到咱們正在尋找的元素或遍歷完整個列表。若是咱們遍歷完整個列表，則說明正在搜索的元素不存在。

def search(alist,item):
    find = False
    length = len(alist)
    
    for i in range(length):
        if alist[i] == item:
            find = True
            
    return find

alist = [3,8,5,7,6,4]
print(search(alist,51))


#False

 

　　2.順序查找(列表有序)

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

alist = [1,3,5,7,9,11]
print(search(alist,5))

#True

 

　　3.二分查找(重要)

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

 

def search(alist,item):
    last = len(alist)-1
    first = 0
    find = False
    
    while first<=last and not find:
        mid = (last+first) // 2
        if alist[mid] == item:
            find = True
        else:
            if alist[mid] > item:
                last = mid - 1
            else:
                first = mid + 1
    return find

alist = [1,3,5,7,9]
print(search(alist,31))

# False

 

二.二叉樹

二叉樹
　　- 跟節點
　　- 左葉子節點
　　- 右葉子節點
　　- 子樹

二叉樹遍歷
　　廣度遍歷：層級遍歷
　　深度遍歷
　　　　前序：根左右
　　　　中序：左根右
　　　　後序：左右根
排序二叉樹

 

 

 

　　1.二叉樹的建立及廣度遍歷

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

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]
        
        while queue:
            cur = queue.pop(0)
            if cur.left == None:
                cur.left = node
                return
            else:
                queue.append(cur.left)
            if cur.right == None:
                cur.right = node
                return
            else:
                queue.append(cur.right)
    #廣度遍歷
    def travel(self):
        queue = [self.root]
        while queue:
            cur = queue.pop(0)
            print(cur.item)
            if cur.left is not None:
                queue.append(cur.left)
            if cur.right is not None:
                queue.append(cur.right)

tree = Tree()
tree.add(1)
tree.add(2)
tree.add(3)
tree.add(4)
tree.add(5)
tree.add(6)
tree.add(7)
tree.add(8)
tree.add(9)
tree.add(10)
tree.travel()

# 1 2 3 4 5 6 7 8 9 10

 

　　2.深度遍歷

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

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]
        
        while queue:
            cur = queue.pop(0)
            if cur.left == None:
                cur.left = node
                return
            else:
                queue.append(cur.left)
            if cur.right == None:
                cur.right = node
                return
            else:
                queue.append(cur.right)

    #深度遍歷
    def forward(self,root): #根左右
        if root == None:
            return
        print(root.item,end=' ')
        self.forward(root.left)
        self.forward(root.right)
        
    def mid(self,root):#左根右
        if root == None:
            return
        self.mid(root.left)
        print(root.item,end=' ')
        self.mid(root.right)
        
    def back(self,root):#左右根
        if root == None:
            return
        self.back(root.left)
        self.back(root.right)
        print(root.item,end=' ')

tree = Tree()
tree.add(1)
tree.add(2)
tree.add(3)
tree.add(4)
tree.add(5)
tree.add(6)
tree.add(7)
tree.add(8)
tree.add(9)
tree.add(10)

tree.forward(tree.root)
print('\n')
tree.mid(tree.root)
print('\n')
tree.back(tree.root)
print('\n')

 

結果爲:

1 2 4 8 9 5 10 3 6 7 

8 4 9 2 10 5 1 6 3 7 

8 9 4 10 5 2 6 7 3 1 

 

　　3.排序二叉樹

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
                    return
                else:
                    cur = cur.right

            else:
                if cur.left == None:
                    cur.left = node
                    return
                else:
                    cur = cur.left
        
     #深度遍歷
    def forward(self,root): #根左右
        if root == None:
            return
        print(root.item,end=' ')
        self.forward(root.left)
        self.forward(root.right)
        
    def mid(self,root):#左根右
        if root == None:
            return
        self.mid(root.left)
        print(root.item,end=' ')
        self.mid(root.right)
        
    def back(self,root):#左右根
        if root == None:
            return
        self.back(root.left)
        self.back(root.right)
        print(root.item,end=' ')

tree = Tree()
tree.insert(3)
tree.insert(0)
tree.insert(2)
tree.insert(9)
tree.insert(1)
tree.insert(6)
tree.insert(4)
tree.forward(tree.root)
print('\n')
tree.mid(tree.root)
print('\n')
tree.back(tree.root)
print('\n')