翻书问题或者走台阶问题:
- 共有n个台阶,每次只能上1个台阶或者2个台阶,共有多少种方法爬完台阶。
- 共有n页书,每次只能翻1页或者2页书,共有多少种方法翻完全书。
# f(n)为翻完全书的方法 # 递归写法 def f(n): if n == 1: return 1 if n == 2: return 2 if n > 2: return f(n - 1) + f(n - 2) # 迭代写法,或者叫循环写法 def f(n): res = [0 for i in range(n + 1)] res[1] = 1 res[2] = 2 for i in range(3, n+1): res[i] = res[i - 1] + res[i - 2] return res[n] # 使用缓存 cache = {} def fib(n): if n not in cache.keys(): cache[n] = _fib(n) return cache[n] def _fib(n): if n == 1 or n == 2: return n else: return fib(n-1) + fib(n-2)
当n=20时,结果:
二分查找:
def LinearSearch(array, t): for i in range(len(array)): if array[i] == t: return True return False def BinarySearch(array, t): left = 0 right = len(array) - 1 while left < right: mid = int((left + right) / 2) if array[mid] < t: left = mid + 1 elif array[mid] > t: right = mid - 1 else: return True return False array = list(range(100000000)) import time t1 = time.time() LinearSearch(array, 100000001) t2 = time.time() print('line:', t2 - t1) t3 = time.time() BinarySearch(array, 100000001) t4 = time.time() print('binary:', t4 - t3)
结果:
链表:
链表中最简单的一种是单向链表,它包含两个域,一个信息域和一个指针域。这个链接指向列表中的下一个节点,而最后一个节点则指向一个空值。
# 链表中的节点的数据结构 class ListNode(object): def __init__(self, x): self.val = x self.next = None # 实例化 A = ListNode('a') B = ListNode('b') C = ListNode('c') A.next = B B.next = C # 这样,一条链表就形成了。 # 'a' -> 'b' -> 'c' # 迭代遍历链表 tmp = A while tmp != None: print(tmp.val) tmp = tmp.next # 递归遍历链表 def listorder(head): if head: print(head.val) listorder(head.next) listorder(A)
例题
翻转一条单向链表。
例子:
Input: 1->2->3->4->5->NULL
Output: 5->4->3->2->1->NULL
# Definition for singly-linked list. class ListNode(object): def __init__(self, x): self.val = x self.next = None class Solution(object): def reverseList(self, head): """ :type head: ListNode :rtype: ListNode """ dummy = head tmp = dummy while head and head.next != None: dummy = head.next head.next = dummy.next dummy.next = tmp tmp = dummy return dummy head = ListNode(1) head.next = ListNode(2) head.next.next = ListNode(3) head.next.next.next = ListNode(4) head.next.next.next.next = ListNode(5) solution = Solution() reverse_head = solution.reverseList(head) tmp = reverse_head while tmp: print(tmp.val) tmp = tmp.next
二叉树:
class TreeNode(object): def __init__(self, x): self.val = x self.left = None self.right = None root = TreeNode(1) root.left = TreeNode(2) root.right = TreeNode(3) ''' 1 / \ 2 3 ''' # root就是一颗二叉树
中序遍历(先遍历左子树,再遍历根节点,再遍历右子树)
# class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None def inorder(root): if root: inorder(root.left) print(root.val) inorder(root.right)
前序遍历(先遍历根节点,再遍历左子树,再遍历右子树)
class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None def preorder(root): if root: print(root.val) preorder(root.left) preorder(root.right) root = TreeNode(1) root.left = TreeNode(2) root.right = TreeNode(3) preorder(root)
后序遍历(先遍历左子树,再遍历右子树,再遍历根节点)
# class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None def postorder(root): if root: postorder(root.left) postorder(root.right) print(root.val)
测试程序:
class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None def preorder(root): if root: print(root.val) preorder(root.left) preorder(root.right) def inorder(root): if root: inorder(root.left) print(root.val) inorder(root.right) def postorder(root): if root: postorder(root.left) postorder(root.right) print(root.val) root = TreeNode(1) root.left = TreeNode(2) root.right = TreeNode(3) root.left.left = TreeNode(4) root.left.right = TreeNode(5) root.right.left = TreeNode(6) root.right.right = TreeNode(7) preorder(root) inorder(root) postorder(root)
已知一颗二叉树的先序遍历序列为ABCDEFG,中序遍历为CDBAEGF,能否唯一确定一颗二叉树?如果可以,请画出这颗二叉树。
A
/ \
B E
/ \
C F
\ /
D G
先序遍历: ABCDEFG
中序遍历: CDBAEGF
后序遍历: DCBGFEA
使用程序根据二叉树的先序遍历和中序遍历来恢复二叉树。
class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None def buildTree(preorder, inorder): if len(preorder) == 0: return None if len(preorder) == 1: return TreeNode(preorder[0]) root = TreeNode(preorder[0]) index = inorder.index(root.val) root.left = buildTree(preorder[1 : index + 1], inorder[0 : index]) root.right = buildTree(preorder[index + 1 : len(preorder)], inorder[index + 1 : len(inorder)]) return root preorder_string = 'ABCDEFG' inorder_string = 'CDBAEGF' r = buildTree(preorder_string, inorder_string) preorder(r) inorder(r) postorder(r)