搜索和二叉树(动图解析)_常见的查找算法动图

搜索

搜索是在一个项目集合中找到一个特定项目的算法过程。搜索通常的答案是真的或假的，因为该项目是否存在。 搜索的几种常见方法：顺序查找、二分法查找、二叉树查找、哈希查找。

二分法查找

首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

算法分析

// An highlighted block
'''递归实现，产生新的数组进行查找'''
def binary_search(alist, item):
    n=len(alist)
    if n>0:
        midpoint = n//2
        if alist[midpoint]==item:
          return True
        else:
        # 调用binary_search实现递归，再次查找
          if item<alist[midpoint]:
            return binary_search(alist[:midpoint],item)
          else:
            return binary_search(alist[midpoint+1:],item)

testlist = [5,7,11,13,20,30,65]
print("递归实现")
print(binary_search(testlist, 3))
print(binary_search(testlist, 13))

'''非递归实现，在原本的数组中查找'''
def binary_search(alist, item):
    first = 0
    last = len(alist) - 1
    while first <= last:
        midpoint = (first + last) //2
        #按重点值左右查找
        if alist[midpoint] == item:
            return True
        elif item < alist[midpoint]:
            last = midpoint - 1
        else:
            first = midpoint + 1
    return False
testlist = [5,7,11,13,20,30,65]
print("非递归实现")
print(binary_search(testlist, 3))
print(binary_search(testlist, 13))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。

时间复杂度

最优时间复杂度：O(1)
最坏时间复杂度：O(logn)

树与树算法

树（英语：tree）是一种**抽象数据类型（ADT）或是实作这种抽象数据类型的数据结构，**用来模拟具有树状结构性质的数据集合。它是由n（n>=1）个有限节点组成一个具有层次关系的集合。

特点：
每个节点有零个或多个子节点；
没有父节点的节点称为根节点；
每一个非根节点有且只有一个父节点；
除了根节点外，每个子节点可以分为多个不相交的子树；

树的种类

无序树

树中任意节点的子节点之间没有顺序关系，这种树称为无序树，也称为自由树；

有序树

树中任意节点的子节点之间有顺序关系，这种树称为有序树；

1. 二叉树：每个节点最多含有两个子树的树称为二叉树；
   完全二叉树：对于一颗二叉树，假设其深度为d(d>1)。除了第d层外，其它各层的节点数目均已达最大值，且第d层所有节点从左向右连续地紧密排列，这样的二叉树被称为完全二叉树，其中满二叉树的定义是所有叶节点都在最底层的完全二叉树。
   
   满二叉树：除了叶节点以外，每个节点都有左右子叶，并且叶子节点都处在最低层的二叉树
   
   平衡二叉树（AVL树）：当且仅当任何节点的两棵子树的高度差不大于1的二叉树。
   

排序二叉树（二叉查找树（英语：Binary Search Tree），也称二叉搜索树、有序二叉树）；

2. 霍夫曼树（用于信息编码）：带权路径最短的二叉树称为哈夫曼树或最优二叉树；
3. B树：一种对读写操作进行优化的自平衡的二叉查找树，能够保持数据有序，拥有多余两个子树。

二叉树

二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。

二叉树的性质(特性)

性质1: 在二叉树的第i层上至多有2^(i-1)个结点（i>0）
性质2: 深度为k的二叉树至多有2^k - 1个结点（k>0）
性质3: 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1;
性质4:具有n个结点的完全二叉树的深度必为 log2(n+1)
性质5:对完全二叉树，若从上至下、从左至右编号，则编号为i 的结点，其左孩子编号必为2i，其右孩子编号必为2i＋1；其双亲的编号必为i/2（i＝1 时为根,除外）

二叉树的遍历

树的遍历是树的一种重要的运算。所谓遍历是指对树中所有结点的信息的访问，即依次对树中每个结点访问一次且仅访问一次，我们把这种对所有节点的访问称为遍历（traversal）。那么树的两种重要的遍历模式是深度优先遍历和广度优先遍历,深度优先一般用递归，广度优先一般用队列。一般情况下能用递归实现的算法大部分也能用堆栈来实现。

广度优先遍历

从树的root开始，从上到下从从左到右遍历整个树的节点。

// An highlighted block
class Node(object):
    """节点类"""
    def __init__(self, item):
        self.elem = item
        self.lchild = None   #设为左边的孩子
        self.rchild = None   #设为右边的孩子
"""二叉树"""
class Tree(object):
    def __init__(self):
        self.root = None

    """为树添加节点"""
    def add(self, item):
        node = Node(item)            #构建节点
        #如果树是空的，则对根节点赋值
        if self.root == None:
            self.root = node
            return
        queue=[self.root]
        while queue:
            #弹出队列的第一个元素
            cur_node = queue.pop(0)
            #如果左边的孩子是否为空，为空，则进行赋值
            #判断左边的孩子是否为空，不为空，则对下一个进行判断
            if cur_node.lchild == None:
                cur_node.lchild = node
                return
            else:
                queue.append(cur_node.lchild)
                # 如果右边的孩子是否为空，为空，则进行赋值
                # 判断右边的孩子是否为空，不为空，则对下一个进行判断
            if  cur_node.rchild == None:
                cur_node.rchild = node
                return
            else:
                #如果左右子树都不为空，加入队列继续判断
                queue.append(cur_node.rchild)
    '''广度遍历'''
    def breadth_travel(self):
        if self.root is None:
            return
        queue = [self.root]
        while queue:
            cur_node=queue.pop(0)
            print(cur_node.elem)
            if cur_node.lchild is not None:
                queue.append(cur_node.lchild)
            if cur_node.rchild is not None:
                queue.append(cur_node.rchild)
if __name__=="__main__":
    tree=Tree()
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(4)
    tree.add(5)
    tree.breadth_travel()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

深度优先遍历

对于一颗二叉树，深度优先搜索(Depth First Search)是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。
那么深度遍历有重要的三种方法。这三种方式常被用于访问树的节点，它们之间的不同在于访问每个节点的次序不同。这三种遍历分别叫做先序遍历（preorder），中序遍历（inorder）和后序遍历（postorder）。

先序遍历

根节点->左子树->右子树

// An highlighted block
 """递归实现先序遍历"""
 def preorder(self, root):
        if root == None:
            return
        print(root.elem,end="\t")
        self.preorder(root.lchild)
        self.preorder(root.rchild)
1
2
3
4
5
6
7
8

中序遍历

左子树->根节点->右子树

  """递归实现中序遍历"""
 def inorder(self, root):
        if root == None:
            return
        self.inorder(root.lchild)
        print(root.elem,end="\t")
        self.inorder(root.rchild)
1
2
3
4
5
6
7

后序遍历

左子树->右子树->根节点

// An highlighted block
  """递归实现后续遍历"""
def postorder(self, root):
      if root == None:
          return
      self.postorder(root.lchild)
      self.postorder(root.rchild)
      pprint(root.elem,end="\t")
1
2
3
4
5
6
7
8

二叉树由遍历确定一棵树

先序遍历 0137849256 规则：根左右
中序遍历 7381940526 规则：左根右