将两串链表合并成一串（保持有序）。题目很简单，思路是用两个指针分别遍历两串链表，同时比较节点值，取小的那一边并将指针向右移动。代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def mergeTwoLists(self, l1, l2): """ :type l1: ListNode :type l2: ListNode :rtype: ListNode """ if not l1 and not l2: return None if not l1: start = l2 elif not l2: start = l1 else: start = l1 if l1.val <= l2.val else l2 if start == l1: p, q = start.next, l2 else: p, q = l1, start.next currNode = start while(p or q): if p and q: if p.val <= q.val: currNode.next = p currNode = p p = p.next else: currNode.next = q currNode = q q = q.next elif p: currNode.next = p currNode = p p = p.next elif q: currNode.next = q currNode = q q = q.next else: pass return start
给出一个整数n，用n个括号()来组成不同的字符串，给出所有的可能。思路是利用括号的合法要求，通过递归，在2 * n长度的字符串中按从左到右的顺序添加左括号或右括号，每添加一个左括号将其加入到一数组中存储，每添加一个右括号检查数组中是否有剩余的左括号（有则删除一个左括号，无则停止递归），在中途有提前停止递归的一些方法（比如左括号的数量已经超过了n），递归停止时左括号剩余0个，则得到一个可能性。代码：
class Solution(object): def generateParenthesis(self, n): """ :type n: int :rtype: List[str] """ allParentheses = [] tempSave = [] _tempSave = '' self._generateParenthesis(tempSave, _tempSave, '(', allParentheses, n - 1, n) return allParentheses def _generateParenthesis(self, tempSave, _tempSave, sign, allParentheses, leftCount, rightCount): _tempSave += sign if leftCount == 0 and rightCount == 0: if tempSave[-1] == '(' and sign == ')': allParentheses.append(_tempSave) return if sign == ')': if tempSave and tempSave[-1] == '(': tempSave.pop() if leftCount > 0: self._generateParenthesis([x for x in tempSave], _tempSave, '(', allParentheses, leftCount - 1, rightCount) if rightCount > 0: self._generateParenthesis([x for x in tempSave], _tempSave, ')', allParentheses, leftCount, rightCount - 1) else: return else: tempSave.append(sign) if leftCount > 0: self._generateParenthesis([x for x in tempSave], _tempSave, '(', allParentheses, leftCount - 1, rightCount) if rightCount > 0: self._generateParenthesis([x for x in tempSave], _tempSave, ')', allParentheses, leftCount, rightCount - 1)
合并k个有序链表，返回一个有序链表。思路是用数组来帮忙存储所有节点的值，最后利用记录下来的所有值重新创建一个新的链表。代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def mergeKLists(self, lists): """ :type lists: List[ListNode] :rtype: ListNode """ mergeList = [] for _list in lists: tempList = [] p = _list while(p): tempList.append(p.val) p = p.next mergeList += tempList mergeList.sort() start, p, q = None, None, None print mergeList if mergeList: for i in mergeList: node = ListNode(i) if not start: start = p = q = node else: if p == q: q = node p.next = q else: p = q q = node p.next = q return start
给出一串链表，将这串链表节点两两置换（前后位置交换，不能通过改变值实现）。按着题目的要求做节点的位置交换即可，注意做完置换后跳到下一组节点的位置，以及置换后与相邻节点联系的建立。代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def swapPairs(self, head): """ :type head: ListNode :rtype: ListNode """ if not head: return if not head.next: return head p = q = head while(p and p.next): _p = p pnext = p.next if q == head: head = pnext _p.next = pnext.next head.next = _p p = _p.next else: q.next = pnext _p.next = pnext.next pnext.next = _p p = _p.next q = _p return head
上一题的升级版，给出一串链表，每k个节点进行一次逆序操作（不满k个节点则不进行操作）。思路是用数组帮忙实现，一边遍历链表，一边将节点存储到数组中，每存储k个节点，对数组进行逆序操作，然后将逆序后的头尾节点与链表重新连结起来。代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def reverseKGroup(self, head, k): """ :type head: ListNode :type k: int :rtype: ListNode """ if k <= 1: return head tempList = [] i = 0 p = q = head while(p or i == k): if i == k: if q == head: tempList.reverse() head = tempList[0] for j, node in enumerate(tempList[0:-1]): node.next = tempList[j + 1] else: tempList.reverse() q.next = tempList[0] for j, node in enumerate(tempList[0:-1]): node.next = tempList[j + 1] tempList[-1].next = p q = tempList[-1] i = 0 tempList = [] i += 1 tempList.append(p) p = p.next if p else None return head
给出一个有序整数数组，将里面重复的数移除。由于是有序数组，相同的数一定在一起，所以用一个变量记录上一个数的值即可，遍历一遍数组，遇到与上一个数相同的进行删除，同时遍历的序号不增；不同的话则不进行操作，序号增加。
class Solution(object): def removeDuplicates(self, nums): """ :type nums: List[int] :rtype: int """ if not nums: return i = 1 currNum = nums[0] while(i <= len(nums) - 1): if nums[i] == currNum: nums.pop(i) else: currNum = nums[i] i += 1 return len(nums)
（27题在之前的博客中做过）。给出总字符串和目标字符串，找出目标字符串在总字符串中的位置，返回位置序号或者-1。利用Python字符串的index即可。
class Solution(object): def strStr(self, haystack, needle): """ :type haystack: str :type needle: str :rtype: int """ try: return haystack.index(needle) except: return -1