之前沒有接觸過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] + "]"
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:# 將每個節點存放在列表中
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:
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:
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)))
Leetcode初級演算法
不是很難的一道動態規劃的題，感覺做多了就記住了。class solution return dp n 此題想法就是，只要後面買的減去前面買的能大於0，就算在內，每次買完和max比較，大於max就記錄為max，如果買的sum小於0了，重新開始買，sum記為0 class solution if sum...
Leetcode 初級演算法02
了解的知識 1.空間複雜度 空間複雜度 space complexity 是對乙個演算法在執行過程中臨時占用儲存空間大小的量度。這樣子理解起來有點困難，我們又了解到當乙個演算法的空間複雜度為乙個常量，即不隨被處理資料量n的大小而改變時，可表示為o 1 舉兩個例子 a.陣列的隨機訪問就是o 1 b.鍊...
LeetCode初級演算法C
class solution temp len s i else if s i 0 s i 9 int i 0,j len 1 while i j else break if i j return true else return false 暴力求解，開闢了100010的陣列。class solu...