1.連結串列Linked list

連結串列（Linked list）是一種常見的基礎資料結構，是一種線性表，但是不像順序表一樣連續儲存資料，而是在每一個節點（資料儲存單元）裡存放下一個節點的位置資訊（即地址）。

連結串列一個節點包含資料儲存單元和下一個節點的位置資訊單元

2.連結串列和順序表的區別

2.1 順序表

• 構建需要預先知道資料大小來申請連續的儲存空間，而在進行擴充時又需要進行資料的搬遷，所以使用起來並不是很靈活。
• 順序表隨機讀取資料比較快

2.2 連結串列

• 連結串列結構可以充分利用計算機記憶體空間，實現靈活的記憶體動態管理。
• 由於增加節點的指標域,空間開銷比較大

3.連結串列和列表的區別

• 連結串列是非順序表， 而列表是順序表

• 連結串列在插入資料的時候，會比列表快很多

• 在查詢資料的時候列表卻更為優勢

4.單向連結串列的特性

單向連結串列也叫單鏈表，是連結串列中最簡單的一種形式，它的每個節點包含兩個域，一個資訊域（元素域）和一個連結域。

這個連結指向連結串列中的下一個節點，而最後一個節點的連結域則指向一個空值。

5.實現單向連結串列的python程式碼

5.1 單鏈表的操作

is_empty() 連結串列是否為空
length() 連結串列長度
travel() 遍歷整個連結串列
add(item) 連結串列頭部新增元素
append(item) 連結串列尾部新增元素
insert(pos, item) 指定位置新增元素
remove(item) 刪除節點
search(item) 查詢節點是否存在
 

5.2 單鏈表的程式碼實現

""""單向連結"""""

class Node(object):
    # 節點類
    def __init__(self,item):
        self.item = item  # 記錄存放資料
        self.next = None  # 記錄下一個節點


class SingleLinkList(object):
    # 單鏈表類
    def __init__(self):
        # 所有操作都是從頭開始,需要記錄頭結點
        self.__head = None

    def is_empty
 
(self):
        """連結串列是否為空"""
        return self.__head is None

    def length(self):
        """連結串列長度"""
        # 定義計數器,遍歷連結串列
        count = 0
        cur = self.__head
        while cur is not None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍歷整個連結串列"""
        # 定義遊標,從頭向尾移動
        cur = self.__head
        while cur is not None:
            print(cur.item,end="")
            cur = cur.next
            print()

    def add(self,item):
        """連結串列頭部新增元素"""
        # 建立新的節點
        node = Node(item)
        # 讓新節點的next 指向原來的頭結點
        node.next = self.__head
        # 讓head指向新節點
        self.__head = node

    def append(self,item):
        """"連結串列尾部新增元素"""
        # 判斷連結串列是否為空, 不為空就是false
        if self.is_empty():
            # 如果為空,則直接按照add從頭新增的方式新增元素,否則連結串列有元素,就直接按照末尾的狀態新增
            self.add(item)
            return
        # 第一步,找尾節點
        cur = self.__head
        while cur.next is not None:
            # 第二步,尾節點指向新節點
            cur = cur.next
        # while 迴圈結束,cur指向尾節點
        # 第二步,尾節點指向新節點\
        node = Node(item)
        cur.next = node

    def insert(self,pos, item):
        """指定位置新增元素"""
        # 保證程式碼的健壯性

        if pos < 0:
            # 前面新增
            self.add(item)
        elif pos >= (self.length()-1):
            # 尾部新增
            self.append(item)
        else:
            # 1 定義下標,與遊標同步變化
            index = 0
            cur = self.__head

            while index < pos -1:
                index += 1
                cur = cur.next
            # 迴圈結束後,cur指向pos前置節點-
            node = Node(item)
            # 2 讓新節點的next 指向pos位置節點
            node.next = cur.next
            # 3. 讓pos位置的前置節點指向新節點
            cur.next = node

    def remove(self,item):
        """刪除節點"""
        # 記錄當前節點的前置節點
        pre = None # cur前置節點
        cur =self.__head
        while cur is not None:
            if cur.item == item:
                # 刪除節點
                # 如果pre為空,證明刪除的是頭節點
                if pre is None:
                    self.__head = cur.next
                else:
                    pre.next = cur.next
                return
            # pre 一直記錄cur的前置節點
            pre = cur
            cur = cur.next

    def search(self,item):
        """查詢節點是否存在"""
        cur = self.__head
        while cur is not None:
            if cur.item == item:
                return True
            cur = cur.next
        return False


if __name__ == '__main__':
    sll = SingleLinkList()
    print(sll.length())
    print(sll.is_empty())
    sll.add(3)
    print(sll.is_empty())
    sll.add(2)
    sll.add(1)
    sll.travel()
    print(sll.length())
    sll.append(4)
    sll.travel()
    sll.insert(2, 6)
    sll.travel()
    sll.insert(-10, 7)
    sll.travel()
    sll.insert(10, 5)
    sll.travel()
    sll.remove(3)
    sll.travel()
    sll.remove(7)
    sll.travel()
    sll.remove(5)
    sll.travel()
    print(sll.search(1))
    print(sll.search(6))
    print(sll.search(4))
    print(sll.search(5))

6.連結串列和順序表操作複雜度對比

注意雖然表面看起來複雜度都是 O(n)，但是連結串列和順序表在插入和刪除時進行的是完全不同的操作。

• 連結串列的主要耗時操作是遍歷查詢，刪除和插入操作本身的複雜度是O(1)。

• 順序表查詢很快，主要耗時的操作是拷貝覆蓋。

因為除了目標元素在尾部的特殊情況，順序表進行插入和刪除時需要對操作點之後的所有元素進行前後移位操作，只能通過拷貝和覆蓋的方法進行。

以上內容僅是代表個人總結 若有錯誤之處,還請批評指正,歡迎大家一起學習!