一、單鏈表

單鏈表：從兩點出發，節點、連結串列；每個節點具有兩個屬性：val和next

1、設計連結串列並實現以下功能：

'''
設計單鏈表， 連結串列的節點包含兩個屬性：val和next，
'''

class Node(object):   # 節點
    def __init__(self, val):
        self.val = val  # 使用引數值來初始化一個節點
        self.next = None


class MyLinkedList(object):  # 連結串列

    def __init__(self):
        """
        初始化連結串列
        
 
"""
        self.head = Node(0)  # 初始化一個數據為0的空節點作為頭部, 本身不算節點
        self.size = 0  # 整個連結串列的長度初始化為0

    def get(self, index: int) -> int:
        """
        獲取連結串列中第index個節點的值,如果無該索引則返回-1
        """
        if index < 0 or index >= self.size:
            return -1
        cur = self.head
        
 
for i in range(index+1):  # 獲取第index個節點
            cur = cur.next
        return(cur.val)

    def addAtHead(self, val: int) -> None:
        """
        在連結串列的第一個元素之前新增一個值為val的節點,插入後,新節點將成為連結串列的第一個節點
        """
        head = self.head
        cur = Node(val)  # 初始化新節點
        cur.next = head.next
        head.next 
 
= cur
        self.size += 1
        # self.addAtIndex(0, val)  #可直接呼叫函式addAtIndex

    def addAtTail(self, val: int) -> None:
        """
        將值為val的節點追加到連結串列的末尾
        """
        prev = self.head
        for i in range(self.size):  # 獲取最後一個節點
            prev = prev.next
        cur = Node(val)  # 初始化新節點
        cur.next = prev.next
        prev.next = cur
        self.size += 1
        # self.addAtIndex(self.size, val)

    def addAtIndex(self, index: int, val: int):
        """
       在連結串列的第index個節點之前新增值為val的節點,
       如果index=size,則該節點附加到連結串列的末尾;如果index>size,則不插入; 如果index<0,則在頭部插入
        """
        if index < 0:
            index = 0
        prev = self.head
        for i in range(index):
            prev = prev.next
        cur = Node(val)
        cur.next = prev.next
        prev.next = cur
        self.size += 1

    def deleteAtIndex(self, index: int) -> None:
        """
        如果索引有效,則刪除連結串列中的第index個節點
        """
        if index < self.size:
            prev = self.head
            for i in range(index):
                prev = prev.next
            prev.next = prev.next.next

# list = MyLinkedList()
# print(MyLinkedList)
# print(list.addAtHead(1))
# print(list.addAtTail(3))
# print(list.addAtIndex(1, 2))
# print(list.get(1))
# print(list.deleteAtIndex(1))
# print(list.get(1))

2、環形連結串列（雙指標）

#  判斷連結串列中是否有環
#  1、使用快慢指標，如果快指標迴圈趕上了慢指標，則代表連結串列中有環
#  2、使用雜湊表，雜湊表中不允許有重複元素(若連結串列有環，則有重複節點）


class Solution:  # 使用快慢指標判斷連結串列是否有環
    def hasCycle_fs(self, head: Node) -> bool:   # head：Node（初始化head節點）
        fast = head
        slow = head
        while fast and slow and fast.next:  # 需判斷若連結串列為空/下一個節點為None（while fast and None ）或只有一個節點的情況（while fast.next)
            fast = fast.next.next
            slow = slow.next
            if fast.val == slow.val:
                return True
        return False

    def hascycle_set(self,head: Node) -> bool:  # 使用雜湊表
        s1 = set()
        s1.add(head)
        cur = head
        while cur and cur.next:
            cur = cur.next
            if cur.next in s1:
                return True
            s1.add(cur)
        return False

3、反轉連結串列：可使用迭代的方法，也可使用棧實現

# 反轉連結串列， 使用next記錄連結串列的下一個節點並迭代連結串列的節點， 將當前節點插入返回的連結串列的頭部

class Node(object):   # 節點
    def __init__(self, val):
        self.val = val  # 使用引數值來初始化一個節點
        self.next = None

class Solution():
    def reverseList(self, head: Node) -> Node:
        head_ret = Node(None)
        cur = head
        while cur:
            next = cur.next # 將next指向下個節點
            cur.next = head_ret.next  # 將當前節點插入head_ret連結串列頭部的後面（返回時不返回定義的頭部）
            head_ret.next = cur
            cur = next  # 迭代當前連結串列的節點（知道當前節點為空）
        return head_ret.next

l1 = Node(1)
l2 =Node(2)
l3 =Node(3)

l1.next = l2
l2.next = l3
l3.next = None

m = Solution()
head = m.reverseList(l1)
print(head.val)
print(head.next.val)
print(head.next.next.val)