1.數組的相對排序（2019.12.20）
題目描述：
給你兩個數組，arr1 和 arr2，
arr2 中的元素各不相同
arr2 中的每個元素都出現在 arr1 中
對 arr1 中的元素進行排序，使 arr1 中項的相對順序和 arr2 中的相對順序相同。未在 arr2 中出現過的元素需要按照升序放在 arr1 的末尾。
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/relative-sort-array
著作權歸領釦網絡所有。商業轉載請聯繫官方授權，非商業轉載請註明出處。
解題思路：
定義空列表res，遍歷arr2所有元素，如果該元素也在arr1中，將arr1中的該元素移除，將該元素添加到res，最後返回res+sorted(arr1)
代碼實現：
class Solution:
def relativeSortArray(self, arr1: List[int], arr2: List[int]) -> List[int]:
res=[]
#遍歷arr2
for i in arr2:
#如果i在arr1中，將i添加到res中，同時移出arr1中的i
while i in arr1:
res.append(i)
arr1.remove(i)
#返回得到的res+剩餘arr1的升序排列部分
return res + sorted(arr1)
2.兩數之和(2019.12.23)
題目描述：
給定一個整數數組 nums 和一個目標值 target，請你在該數組中找出和爲目標值的那 兩個 整數，並返回他們的數組下標。
你可以假設每種輸入只會對應一個答案。但是，你不能重複利用這個數組中同樣的元素。
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/two-sum
著作權歸領釦網絡所有。商業轉載請聯繫官方授權，非商業轉載請註明出處。
解題思路：
- 首先獲取列表的長度，並定義num2的下標j爲-1
- 使用for循環獲取遍歷nums，並對nums進行切片，獲取當前元素之前的元素爲一個新的列表temps
- 如果taget-nums[i]在列表temps中，獲取num2的下標，並跳出循環
- 如果j>=0時，說明taget = num1+num2成立，返回num1和num2的下標
代碼實現：
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
lens = len(nums)
j = -1
for i in range(1,lens):
#對nums切片獲取i之前的元素，作爲新的列表
temps = nums[:i]
#如果target-nums[i]在temps中，獲取j的下標，跳出循環
if (target - nums[i]) in temps:
j = temps.index(target - nums[i])
break
if j >= 0:
return j,i
3.整數反轉（2019.12.24）
題目描述：
給出一個 32 位的有符號整數，你需要將這個整數中每位上的數字進行反轉。
示例 1:
輸入: 123
輸出: 321
示例 2:
輸入: -123
輸出: -321
示例 3:
輸入: 120
輸出: 21
注意:
假設我們的環境只能存儲得下 32 位的有符號整數，則其數值範圍爲 [−231, 231 − 1]。請根據這個假設，如果反轉後整數溢出那麼就返回 0。
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/reverse-integer
著作權歸領釦網絡所有。商業轉載請聯繫官方授權，非商業轉載請註明出處。
解題思路：
- 將傳入的整型轉換爲字符串num_strs，並定義一個空的列表reverse_strs
- 將num_strs反轉並賦值給reverse_strs，如果reverse_strs最後一位爲‘-’，將其插入到列表的第一位
- 定義空的字符串nums，將reverse_strs各元素累計後賦值給nums，將nums轉換爲整型
- 如果nums<-2**31或nums>2**31-1，將0賦值給nums
代碼實現：
class Solution:
def reverse(self, x: int) -> int:
num_strs = str(x)
reverse_strs = []
#將num_strs進行反轉賦值給reverse_strs
for i in num_strs:
reverse_strs.insert(0,i)
if reverse_strs[-1] == '-':
reverse_strs.insert(0,reverse_strs[-1])
reverse_strs.pop(-1)
nums = ''
#將reverse_strs各元素累加後賦值給nums
for num in reverse_strs:
nums += num
nums = int(nums)
if nums < -2**31 or nums > (2**31-1):
nums = 0
return nums
4.迴文數
題目描述：
判斷一個整數是否是迴文數。迴文數是指正序（從左向右）和倒序（從右向左）讀都是一樣的整數。
示例 1:
輸入: 121
輸出: true
示例 2:
輸入: -121
輸出: false
解釋: 從左向右讀, 爲 -121 。 從右向左讀, 爲 121- 。因此它不是一個迴文數。
示例 3:
輸入: 10
輸出: false
解釋: 從右向左讀, 爲 01 。因此它不是一個迴文數。
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/palindrome-number
著作權歸領釦網絡所有。商業轉載請聯繫官方授權，非商業轉載請註明出處。
解題思路：
- 將整數X轉換爲字符串strs，定義空列表news
- 遍歷字符串strs，將字符串元素反轉存入news
- 將news各元素累加後，賦值給new_str
- new_str等於strs時，返回true，否則，返回false
代碼實現：
class Solution:
def isPalindrome(self, x: int) -> bool:
strs = str(x)
news = []
for i in strs:
news.insert(0,i)
new_str = ''
for new in news:
new_str += new
if new_str == strs:
return True
else:
return False
5.二叉樹的層次遍歷（2019.12.26）
題目描述：
給定一個二叉樹，返回其按層次遍歷的節點值。 （即逐層地，從左到右訪問所有節點）。
例如:
給定二叉樹: [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回其層次遍歷結果：
[
[3],
[9,20],
[15,7]
]
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal
著作權歸領釦網絡所有。商業轉載請聯繫官方授權，非商業轉載請註明出處。
解題思路：
- 定義空列表levels，判斷傳入的節點root是否爲空，如果爲空，返回空列表levels
- 定義遞歸方法helper，入參當前節點node、當前深度level
- 如果levels的長度等於level，在levels最後添加空列表
- 將當前node的值添加到levels[level]中
- 判斷當前節點是否有左子節點，如果有，用左子節點、level+1調用helper方法
- 判斷當前節點是否有右子節點，如果有，用右子節點、level+1調用helper方法
- 調用helper方法，傳入參數爲root、0
- 返回levels
代碼實現：
class Solution:
def levelOrder(self, root: TreeNode) -> List[List[int]]:
#定義一個空列表levels
levels = []
#如果傳入的二叉樹爲空，返回空列表
if not root:
return levels
def helper(node,level):
"""
遞歸遍歷二叉樹
"""
#如果列表的長度等於當前節點的深度，給列表levels中添加一個空的列表
if len(levels) == level:
levels.append([])
#將當前節點的值，添加到列表levels中子列表level下
levels[level].append(node.val)
#判斷當前節點是否有左子節點，如果有，左子節點和level+1調用helper
if node.left:
helper(node.left,level+1)
if node.right:
helper(node.right,level+1)
helper(root,0)
return levels
6.羅馬數字轉整數
題目描述：
羅馬數字包含以下七種字符: I， V， X， L，C，D 和 M。
字符 數值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 羅馬數字 2 寫做 II ，即爲兩個並列的 1。12 寫做 XII ，即爲 X + II 。 27 寫做 XXVII, 即爲 XX + V + II 。
通常情況下，羅馬數字中小的數字在大的數字的右邊。但也存在特例，例如 4 不寫做 IIII，而是 IV。數字 1 在數字 5 的左邊，所表示的數等於大數 5 減小數 1 得到的數值 4 。同樣地，數字 9 表示爲 IX。這個特殊的規則只適用於以下六種情況：
I 可以放在 V (5) 和 X (10) 的左邊，來表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左邊，來表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左邊，來表示 400 和 900。
給定一個羅馬數字，將其轉換成整數。輸入確保在 1 到 3999 的範圍內。
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/roman-to-integer
著作權歸領釦網絡所有。商業轉載請聯繫官方授權，非商業轉載請註明出處。
解題思路：
- 將各種羅馬數字對應的值放到字典RomanToNum中，初始化n爲傳入字符串的長度，i、res都爲0
- 使用while，當i小於n時繼續循環
- 如果i等於n-1說明其爲字符串中最後一位，不可能爲IV等情況，對res加RomanToNum[s[i]]，i加1
- 如果字符串s當前元素及下一個元素存在與RomanToNum中，說明s[i:i+2]爲特例，那麼對res加RomanToNum[s[i:i+2]],i加2
- 如果不滿足條件3、4，則說明該元素既不是特列，也不是字符串的最後一位，只需要對res加加RomanToNum[s[i]]，i加1即可
- 返回res
代碼實現：
class Solution:
def romanToInt(self, s: str) -> int:
RomanToNum = {
"I":1,
"IV":4,
"V":5,
"IX":9,
"X":10,
"XL":40,
"L":50,
"XC":90,
"C":100,
"CD":400,
"D":500,
"CM":900,
"M":1000
}
n = len(s)
i = 0
res = 0
while i<n:
if i == n-1:
res += RomanToNum[s[i]]
i += 1
else:
if s[i:i+2] in RomanToNum:
res += RomanToNum[s[i:i+2]]
i += 2
else:
res += RomanToNum[s[i]]
i += 1
return res
7.最長公共前綴(2019.12.28)
題目描述：
編寫一個函數來查找字符串數組中的最長公共前綴。
如果不存在公共前綴，返回空字符串 ""。
示例 1:
輸入: ["flower","flow","flight"]
輸出: "fl"
示例 2:
輸入: ["dog","racecar","car"]
輸出: ""
解釋: 輸入不存在公共前綴。
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/longest-common-prefix
著作權歸領釦網絡所有。商業轉載請聯繫官方授權，非商業轉載請註明出處。
解題思路：
- 判斷傳入的字符串數組是否爲空，如果爲空直接返回空字符串，如果不爲空定義res等於傳入的字符串數組第一個元素
- 遍歷整個數組，如果res爲空，則直接返回res，如果不爲空，和當前元素前len(res)進行比較，如果相等跳出本次循環。
- 如果不等，將res最後一位刪除，重新進行比較，直到相等或res爲空
代碼實現：
class Solution:
def longestCommonPrefix(self, strs: List[str]) -> str:
#如果strs不爲空
if strs:
#定義res等於strs[0]
res = strs[0]
#遍歷列表strs
for string in strs:
#如果res爲空，則說明沒有相同的前綴，直接返回res
if not res:
return res
#如果res等於當前字符串相同位數的前綴，跳出本次循環
if res == string[0:len(res)]:
continue
#res不等於字符串相同位數的前綴，去除res的最後一位繼續比較，直到等於或res爲空爲止
else:
while res != string[0:len(res)]:
res = res[0:len(res) -1]
return res
else:
res = ''
#如果爲空直接返回空字符串
return res
8.有效的括號（2019.12.29）
題目描述：
給定一個只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判斷字符串是否有效。
有效字符串需滿足：
左括號必須用相同類型的右括號閉合。
左括號必須以正確的順序閉合。
注意空字符串可被認爲是有效字符串。
示例 1:
輸入: "()"
輸出: true
示例 2:
輸入: "()[]{}"
輸出: true
示例 3:
輸入: "(]"
輸出: false
示例 4:
輸入: "([)]"
輸出: false
示例 5:
輸入: "{[]}"
輸出: true
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/valid-parentheses
著作權歸領釦網絡所有。商業轉載請聯繫官方授權，非商業轉載請註明出處。
解題思路：
- 判斷是否爲空字符串，如果是返回true
- 定義n爲字符串長度的一般，i爲0
- 使用while循環，如果"()"或"{}"或"[]"在字符串s中，使用空字符串替換空格，否則直接返回false
- 如果s爲空，返回true
代碼實現：
class Solution:
def isValid(self, s: str) -> bool:
if not s:
return True
n = len(s)//2
i = 0
while i < n:
i += 1
if "()" or "[]" or "{}" in s:
s = s.replace("()","")
s = s.replace("[]", "")
s = s.replace("{}", "")
else:
return False
if not s:
return True
9.刪除排序數組中的重複項（2019.12.30）
題目描述：
給定一個排序數組，你需要在原地刪除重複出現的元素，使得每個元素只出現一次，返回移除後數組的新長度。
不要使用額外的數組空間，你必須在原地修改輸入數組並在使用 O(1) 額外空間的條件下完成。
示例 1:
給定數組 nums = [1,1,2],
函數應該返回新的長度 2, 並且原數組 nums 的前兩個元素被修改爲 1, 2。
你不需要考慮數組中超出新長度後面的元素。
示例 2:
給定 nums = [0,0,1,1,1,2,2,3,3,4],
函數應該返回新的長度 5, 並且原數組 nums 的前五個元素被修改爲 0, 1, 2, 3, 4。
你不需要考慮數組中超出新長度後面的元素。
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array
著作權歸領釦網絡所有。商業轉載請聯繫官方授權，非商業轉載請註明出處。
解題思路：
- 判斷數組是否爲空，如果爲空直接返回0
- 定義k爲1，使用for循環遍歷數組nums
- 如果當前元素不等於當前元素所在位置的前一個元素，則說明當前元素不重複，使用nums[k]等於當前元素，並且對k加1
- 返回k
代碼實現：
class Solution:
def removeDuplicates(self, nums: List[int]) -> int:
if not nums: return 0
k = 1
for i in range(1,len(nums)):
if nums[i] != nums[i-1]:
nums[k] = nums[i]
k += 1
return k
10.從二叉搜索樹到更大和樹（2019.12.31）
題目描述：
給出二叉搜索樹的根節點，該二叉樹的節點值各不相同，修改二叉樹，使每個節點 node 的新值等於原樹中大於或等於 node.val 的值之和。（題目描述不理解的話可以參考鏈接：https://leetcode-cn.com/problems/binary-search-tree-to-greater-sum-tree/solution/dui-ti-yi-de-li-jie-by-hardy-5/）
解題思路：
- 定義空列表sort，將節點根據值從小到大存入sort中
- 令sort[i].val等於sort[i].val+sort[i+1].val+...+sort[-1].val
代碼實現：
class Solution:
def bstToGst(self, root: TreeNode) -> TreeNode:
sort = []
def inorder(node):
#在sort中將node從小到大排列
if node:
inorder(node.left)
sort.append(node)
inorder(node.right)
inorder(root)
#令當前node的值等於 當前node和大於當前node值的和
for i in range(len(sort)):
for j in range(i+1,len(sort)):
sort[i].val += sort[j].val
return root
