順序表和鏈表和二叉樹

順序表和鏈表

 

順序表

• 集合中存儲的元素是有順序的，順序表的結構能夠分爲兩種形式：單數據類型和多數據類型。
• python中的列表和元組就屬於多數據類型的順序表

 

• 單數據類型順序表的內存圖（內存連續開啓）
  • 對應的內存空間是連續開闢的
  • 順序表的變量/引用存的的（指向的）是內存空間的首地址

 

• 多數據類型順序表的內存圖（內存非連續開闢）

重點:

• 想把數據存儲到內存中，必須先在內存中開闢指定大小的內存空間（大小，地址：定位
• 若是一個引用指向了某一塊內存空間，則表示該引用存儲了該內存空間的地址

 

• 順序表的弊端：順序表的結構須要預先知道數據大小來申請連續的存儲空間，而在進行擴充時又須要進行數據的搬遷。

 

鏈表: 相對於順序表，鏈表結構能夠充分利用計算機內存空間，實現靈活的內存動態管理且進行擴充時不須要進行數據搬遷。

鏈表（Linked list）是一種常見的基礎數據結構，是一種線性表，可是不像順序表同樣連續存儲數據，而是每個結點（數據存儲單元）裏存放下一個結點的信息（即地址）

 

. is_empty()：鏈表是否爲空

. length()：鏈表長度

. travel()：遍歷整個鏈表

. add(item)：鏈表頭部添加元素

. append(item)：鏈表尾部添加元素

. insert(pos, item)：指定位置添加元素

. remove(item)：刪除節點

. search(item)：查找節點是否存在

 

#封裝節點數據結構
class Node():
    def __init__(self,item):
        self.item = item
        self.next = None
    def __str__(self):
        return self.item
#封裝鏈表數據結構
class Link():
    #初始化一個空鏈表
    def __init__(self):
        #該屬性永遠指向第一個節點
        self._head = None
    def isEmpty(self):
        return self._head == None
    def add(self,item):
        #建立一個新的節點對象
        node = Node(item)
        #將節點插入到鏈表的頭部
        node.next = self._head
        self._head = node
    def travel(self):
        cur = self._head
        while cur:
            print(cur.item)
            cur = cur.next
    def length(self):
        count = 0
        cur = self._head
        while cur:
            count += 1
            cur = cur.next
        return count
    def append(self,item):
        cur = self._head
        pre = None #cur前面節點的地址
        
        node = Node(item)
        #若是鏈表爲空則新節點做爲鏈表中的第一個節點
        if self._head is None:
            self._head = node
            return
        #鏈表非空對應的插入狀況    
        while cur:
            pre = cur
            cur = cur.next
        pre.next = node
      
    def insert(self,pos,item):
        cur = self._head
        pre = None
        node = Node(item)
        length = self.length()
        #對特殊狀況的處理
        if pos > length:
            self.append(item)
            return
        if pos <= 0:
            self.add(item)
            return
        #正常處理
        for i in range(pos):
            pre = cur
            cur = cur.next
        pre.next = node
        node.next = cur
    def remove(self,item):
        cur = self._head
        pre = None
        #若是刪除的是第一個節點
        if item == cur.item:
            self._head = cur.next
            return
        while cur:
            if cur.item == item:
                pre.next = cur.next
                return
            else:
                pre = cur
                cur = cur.next
        
        
    def search(self,item):
        find = False
        cur = self._head
        while cur:
            if cur.item == item:
                find = True
                break
            cur = cur.next
        return find

 

link = Link()
link.add(10)
link.add('aa')
link.append('bobo')
link.append('bobo1')
link.insert(111,666)
# link.remove('aa')
link.travel()
print(link.length())
link.search(6669)

aa
10
bobo
bobo1
666
5

Out[36]:False

 

 二叉樹

• 根節點
• 左葉子節點
• 右葉子節點
• 子樹

 

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

 

 

 實現排序二叉樹

class Node():
    def __init__(self,item):
        self.item = item
        self.left = None
        self.right = None
class Tree():
    def __init__(self):
        self.root = None
        
    def insertByOder(self,item):
        
        node = Node(item)
        if self.root is None:
            self.root = node
            return
        
        cur = self.root
        while True:
            if item < cur.item:
                if cur.left is None:
                    cur.left = node
                    return
                else:
                    cur = cur.left
            else:
                if cur.right is None:
                    cur.right = node
                    return
                else:
                    cur = cur.right
            
    def forward(self,root):
        if root is None:
            return
        # 根 左 右
        print(root.item,end=' ')
        self.forward(root.left)
        self.forward(root.right)
    def mid(self,root):
        if root is None:
            return
        #左根右
        self.mid(root.left)
        print(root.item,end=' ')
        self.mid(root.right)
    def back(self,root):
        if root is None:
            return
        #左右根
        self.back(root.left)
        self.back(root.right)
        print(root.item,end=' ')