LeetCode初級算法的Python實現--鏈表

之前沒有接觸過Python編寫的鏈表，所以這里記錄一下思路。這里前面的代碼是和leetcode中的一樣，因為做題需要調用，所以下面會給出。
首先定義鏈表的節點類。

# 鏈表節點
class ListNode(object):
    def __init__(self, x):
        self.val = x # 節點值
        self.next = None

其次分別定義將列表轉換成鏈表和將鏈表轉換成字符串的函數；

# 將列表轉換成鏈表
def stringToListNode(input):
    numbers = input
    dummyRoot = ListNode(0)
    ptr = dummyRoot
    for number in numbers:
        ptr.next = ListNode(number)# 分別將列表中每個數轉換成節點
        ptr = ptr.next
    ptr = dummyRoot.next
    return ptr


# 將鏈表轉換成字符串
def listNodeToString(node):
    if not node:
        return "[]"
    result = ""
    while node:
        result += str(node.val) + ", "
        node = node.next
    return "[" + result[:-2] + "]"

leetcode初級算法鏈表相關代碼如下：

class Solution(object):
    # 刪除鏈表中的節點
    def deleteNode(self, node):
        """
        :type node: ListNode
        :rtype: void Do not return anything, modify node in-place instead.
        """
        node.val = node.next.val
        node.next = node.next.next
        # print(listNodeToString(node))
    # 刪除鏈表的倒數第N個節點
    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
        listNode = []
        while head:# 將每個節點存放在列表中
            listNode.append(head)
            head = head.next
        if 1 <= n <= len(listNode):# 如果n在列表個數之內的話
            n = len(listNode) - n# n原本是倒數位置，現在賦值為正方向位置
            if n == 0:# 如果是刪除第1個位置的節點
                if len(listNode) > 1:# 如果節點總數大於1
                    listNode[0].val = listNode[1].val# 刪除第1個位置
                    listNode[0].next = listNode[1].next
                else:
                    return None# 因為節點一共就1個或0個，所以刪除1個直接返回None
            else:
                listNode[n - 1].next = listNode[n].next# 將該節點的上一個節點的后節點賦值為該節點的后節點，即刪除該節點
        return listNode[0]
    # 反轉鏈表
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        listNode = []
        while head:
            listNode.append(head)
            head = head.next
        if len(listNode) == 0:
            return None
        for i in range(int(len(listNode) / 2)):# 將節點的值收尾分別調換
            listNode[i].val, listNode[len(listNode) - i - 1].val = listNode[len(listNode) - i - 1].val, listNode[i].val
        return listNode[0]
    # 合並兩個有序鏈表
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        newList = ListNode(0)
        newList.next = l1
        prev= newList# 獲得新鏈表

        while l2:
            if not l1:# 如果l1不存在，直接返回l2即可
                prev.next = l2
                break
            if l1.val > l2.val:# 1，判斷l1和l2哪個大，如果l2小，則將新節點的后面設為l2的頭節點，並將頭節點的后面設置為l1，反之l1小，則直接將頭節點的后面設置為l1，並將節點后移
                temp = l2
                l2 = l2.next
                prev.next = temp
                temp.next = l1
                prev = prev.next#
            else:# 反之l2大於l1，則是l1節點向后移
                l1, prev = l1.next, l1
        return newList.next
    # 回文鏈表
    def isPalindrome(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        listNode = []
        while head:
            listNode.append(head)
            head = head.next
        for i in range(int(len(listNode) / 2)):# 判斷兩頭的值是否一樣大
            if listNode[i].val != listNode[len(listNode) - i - 1].val:
                return False
        return True
    # 環形鏈表
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        if not head:
            return False
        p1=p2=head
        while p2.next and p2.next.next:# p1走1步，p2走兩步，如果在鏈表沒走完的情況下，找到完全相同的節點，就是找到環了
            p1=p1.next
            p2=p2.next.next
            if p1==p2:
                return True
        return False

head = [1,2,3,4,5]
head2 = [4, 5, 8, 9]
s = Solution()

# print(s.deleteNode(stringToListNode(head))) 
# print(listNodeToString(s.removeNthFromEnd(stringToListNode(head), 1)))  # 刪除倒數第一個位置
# print(listNodeToString(s.reverseList(stringToListNode(head))))  # 翻轉
# print(listNodeToString(s.mergeTwoLists(stringToListNode(head2), stringToListNode(head))))  # 合並兩個鏈表
# print(s.isPalindrome(stringToListNode(head)))
# print(s.hasCycle(stringToListNode(head)))