最基础算法(二叉树、二分法、链表、斐波那契)

翻书问题或者走台阶问题：

• 共有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)