沒有 not Coding length delete 標識 explore tails ram

1. 線性表簡介

線性表是一種線性結構，它是由零個或多個數據元素構成的有限序列。線性表的特征是在一個序列中，除了頭尾元素，每個元素都有且只有一個直接前驅，有且只有一個直接後繼，而序列頭元素沒有直接前驅，序列尾元素沒有直接後繼。

數據結構中常見的線性結構有數組、單鏈表、雙鏈表、循環鏈表等。線性表中的元素為某種相同的抽象數據類型。可以是C語言的內置類型或結構體，也可以是C++自定義類型。

2. 數組

數組在實際的物理內存上也是連續存儲的，數組有上界和下界。C語言中定義一個數組：

數組下標是從0開始的，a[0]對應第一個元素。其中，a[0]稱為數組a的下界，a[6]稱為數組a的上屆。超過這個範圍的下標使用數組，將造成數組越界錯誤

。
數組的特點是：數據連續，支持快速隨機訪問。
數組分為固定數組與動態數組。其中固定數組的大小必須在編譯時就能夠確認，動態數組允許在運行時申請數組內存。復雜點的數組是多維數組，多維數組實際上也是通過一維數組來實現的。在C語言中，可以通過malloc來分配動態數組，C++使用new。另外，C++的標準模板庫提供了動態數組類型vector以及內置有固定數組類型array。

Python中list可以被認為是封裝好的數組。

3. 單向鏈表

單向鏈表是鏈表的一種。鏈表由節點所構成，節點內含一個指向下一個節點的指針，節點依次鏈接成為鏈表。因此，鏈表這種數據結構通常在物理內存上是不連續的。鏈表的通常含有一個頭節點，頭節點不存放實際的值，它含有一個指針，指向存放元素的第一個節點。

show me the code

class Node():
    """
    單鏈表中的節點應該具有兩個屬性：val 和 next。
    val 是當前節點的值，
    next 是指向下一個節點的指針/引用。
    """

    def __init__(self, value):
        # 存放元素數據
        self.val = value
        # next是下一個節點的標識
        self.next = None

設計鏈表的實現

您可以選擇使用單鏈表或雙鏈表。單鏈表中的節點應該具有兩個屬性：val

和 next。val 是當前節點的值，next 是指向下一個節點的指針/引用。如果要使用雙向鏈表，則還需要一個屬性 prev 以指示鏈表中的上一個節點。假設鏈表中的所有節點都是 0-index 的。

在鏈表類中實現這些功能：

• get(index)：獲取鏈表中第 index 個節點的值。如果索引無效，則返回-1。

• addAtHead(val)：在鏈表的第一個元素之前添加一個值為 val 的節點。插入後，新節點將成為鏈表的第一個節點。

  

• addAtTail(val)：將值為 val 的節點追加到鏈表的最後一個元素。

• addAtIndex(index,val)：在鏈表中的第 index 個節點之前添加值為 val 的節點。如果 index 等於鏈表的長度，則該節點將附加到鏈表的末尾。如果 index 大於鏈表長度，則不會插入節點。

• deleteAtIndex(index)：如果索引 index 有效，則刪除鏈表中的第 index 個節點。

show me the code

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
@Author    : Young
@Email     : [email protected]
@site      : http://www.cnblogs.com/huang-yc/
@File      : linked_list2.py
@version   : 1.0
@Time      : 2019/4/5 11:06
Description about this file:

"""


class Node():
    """
    單鏈表中的節點應該具有兩個屬性：val 和 next。
    val 是當前節點的值，
    next 是指向下一個節點的指針/引用。
    """

    def __init__(self, value):
        # 存放元素數據
        self.val = value
        # next是下一個節點的標識
        self.next = None


class SingleLinkList():
    def __init__(self, node=None):
        # 頭節點定義為私有變量
        self._head = node

    def is_empty(self):
        # 判斷鏈表是否為空
        if self._head is None:
            return True
        else:
            return False

    def get(self, index: int) -> int:
        """
        獲取鏈表中第 index 個節點的值。如果索引無效，則返回-1
        :param index: 索引值
        :return:
        """
        if self._head is None:
            return -1
        cur = self._head
        for i in range(index):
            if cur.next is None:
                return -1
            cur = cur.next
        return cur.val

    def length(self):
        """
        cur遊標，用來移動遍歷節點
        count用來計數
        :return: 返回鏈表的長度
        """
        cur = self._head
        count = 0
        while cur is not None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """
        遍歷整個鏈表
        :return:
        """
        cur = self._head
        while cur is not None:
            print(cur.elem, end=' ')
            cur = cur.next

    def add_at_head(self, val: int) -> None:
        """
        在頭部添加一個節點
        :param val:
        :return: None
        """
        # 先創建一個保存item值的節點
        node = Node(val)
        # 判斷鏈表是否為空
        if self._head is None:
            self._head = node
        else:
            # 將新節點的鏈接域next指向頭節點，即_head指向的位置
            node.next = self._head
            # 將鏈表的頭_head指向新節點
            self._head = node

    def add_at_tail(self, val: int) -> None or int:
        """
        在尾部添加一個節點
        :param item:
        :return:
        """
        node = Node(val)
        # 若鏈表為空，直接將該節點作為鏈表的第一個元素
        if self._head is None:
            self._head = node
        else:
            cur = self._head
            while cur.next is not None:
                cur = cur.next
            cur.next = node

    def add_at_index(self, index: int, val: int) -> None:
        """
        在指定位置pos添加節點
        pos從0開始
        :param index:
        :param val:
        :return:
        """
        # 若指定位置pos為第一個元素之前，則執行頭部插入
        if index <= 0:
            self.add_at_head(val)
        # 若指定位置超過鏈表尾部，則執行尾部插入
        elif index >= self.length():
            self.add_at_tail(val)
        # 找到指定位置
        else:
            # pre用來指向指定位置pos的前一個位置pos-1，初始從頭節點開始移動到指定位置
            pre = self._head
            count = 0
            node = Node(val)
            # 在目標節點的前一位停下
            while count < (index - 1):
                count += 1
                pre = pre.next
            # 先將新節點node的next指向插入位置的節點
            node.next = pre.next
            # 將插入位置的前一個節點的next指向新節點
            pre.next = node

    def delete_at_index(self, index: int) -> None or int:
        """
        如果索引 index 有效，則刪除鏈表中的第 index 個節點。
        :param index: 對應的索引值
        :return: -1表示為異常
        """
        pre = None
        cur = self._head
        if index is 0:
            self._head = None
        for i in range(index):
            if cur.next is None:
                # raise IndexError("越界")
                return -1
            pre = cur
            cur = pre.next
        else:
            pre.next = cur.next

    def search(self, val: int) -> True or False:
        """
        查找節點是否存在
        :param val: 節點的val值
        :return:
        """
        cur = self._head
        while cur is not None:
            if cur.val == val:
                return True
            else:
                cur = cur.next
        return False


if __name__ == '__main__':
    obj = SingleLinkList()
    obj.add_at_head(1)
    obj.add_at_tail(3)
    obj.add_at_index(1, 2)
    obj.travel()
    obj.delete_at_index(1)
    obj.travel()

鏈表與順序表的對比

鏈表失去了順序表隨機讀取的優點，同時鏈表由於增加了結點的指針域，空間開銷比較大，但對存儲空間的使用要相對靈活。

鏈表與順序表的各種操作復雜度如下所示：

操作	鏈表	順序表
訪問元素	O(n)	O(1)
在頭部插入/刪除	O(1)	O(n)
在尾部插入/刪除	O(n)	O(1)
在中間插入/刪除	O(n)	O(n)

參考資料

https://www.cnblogs.com/QG-whz/p/5170147.html

https://blog.csdn.net/weixin_39881922/article/details/80470896

https://leetcode-cn.com/explore/learn/card/linked-list/193/singly-linked-list/741/

Python線性表——單鏈表