python 实现常见的搜索算法

# coding=utf-8

"""
二分查找的简单介绍
1、二分查找的对象必须是排序后的对象
2、只能作用在顺序表上（支持下表索引）
3、时间复杂度，O(logn)
"""
def binary_search(alist,item):
    """
    二分查找
    :param alist:
    :return:
    """

    start = 0
    end = len(alist)
    mid = (start+end)//2

    if end > start:
        if alist[mid]>item:
            return binary_search(alist[:mid],item)
        elif alist[mid] == item:
            return True
        else:
            return binary_search(alist[mid+1:], item)
    else:
        return False


if __name__ == "__main__":
    alist = [1,2,3,4,5]
    # print(binary_search(alist,5))

#树结构介绍
"""
1、每个节点有零个或多个子节点
2、没有父节点的节点称为根节点
3、每个非根节点有且只有一个父几点
4、除了根节点，每个子节点可以分为多个不相交的子树

树的术语：
1、节点的度：一个节点含有的子树的个数称为节点的度（简单的来说就是指节点下子节点的个数）
2、树的度：树种节点的度的最大值就是树的度
3、叶几点或终端节点：度为零的节点
4、父节点：若一个节点有子节点，则这个节点称为其子节点的父节点
5、兄弟节点：同一个父节点的节点称为父节点
6、节点的层次：从上往下，根节点为第一层，根的子节点为第二层，依次类推
7、树的高度：树中节点的最大层
8、堂兄弟节点：父节点为层上节点的子节点
9、节点祖先：一个节点上的所有节点
10、子孙几点：一个节点下关联的全部节点
11、多个不相交的树的集合称为森林

树的种类
1、无序树：树中的节点中的元素没有任何顺序关联
2、有序树：有顺序结构
    i、二叉树：每个节点最多只含两个子树
        完全二叉树：除了最底层外，其他的所有几点都达到了最大的度
        满二叉树：所有节点的度都达到最大的度
        平衡二叉树：树中子树的高度差不大于一
        排序二叉树：树的左子树上的值均小于等于他的根（不为空），树的右子树上的值均大于等于他的根（不为空），左右子树分别又是二叉树


树的应用场景
1、html、xml等
2、路由协议
3、mysql数据库索引
4、文件系统的目录结构
5、AI经典算法


二叉树性质
1、在二叉树的第i层上至多有2^(i-1)个节点
2、在二叉树的深度为i层，总节点至多有2^i-1个节点
3、对于任意一个二叉树，如果子叶节点数为N0，且度数为2的节点数为N2，则N0 = N2+1
4、完全二叉树节点数为n，则深度为log2(n+1)
5、总节点数n = n0+n1+n2，一个度为2的节点有两个子节点，一个度为一的节点有一个子节点可得n=1+n1+2*n2

推导
n = 2^(k-2)+n0 -1 n1= n0-(n0//2) n2 = 2*(k-2)- 1 + n0//2  n = n0 + n1 +n2
n = n0-(n0//2) + 2*(k-2)- 1 + n0//2 = n0 + 2*(k-2)-1
二叉树的全部节点B = n-1,同时B = n1 + 2*n2，n = n1+2*n2+1，结合n = n0+n1+n2 -->>n0=n2+1


"""
class Node:
    def __init__(self,item):
        self.item = item
        self.lchild = None
        self.rchild = None


class Tree:
    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 is None:
                cur_node.lchild = node
                return
            else:
                queue.append(cur_node.lchild)
            if cur_node.rchild is None:
                cur_node.rchild = node
                return
            else:
                queue.append(cur_node.rchild)

        ##广度遍历
    def breath_travel(self):
        if self.root is None:
            return
        queue = [self.root]
        while queue:
            cur_node = queue.pop(0)
            print(cur_node.item)
            if cur_node.lchild is not None:
                queue.append(cur_node.lchild)
            if cur_node.rchild is not None:
                queue.append(cur_node.rchild)

    ##深度遍历 先序遍历 根 - 左 - 右
    def  preoder(self,node):

        if node == None:
            return
        print(node.item)
        self.preoder(node.lchild)
        self.preoder(node.rchild)



    ##深度遍历 中序遍历   左 - 根 - 右
    def midoder(self, node):

        if node == None:
            return
        self.midoder(node.lchild)
        print(node.item)
        self.midoder(node.rchild)


    ##深度遍历 后序遍历  左 - 右 - 根
    def postoder(self, node):

        if node == None:
            return
        self.postoder(node.lchild)
        self.postoder(node.rchild)
        print(node.item)
# tree = Tree()
# tree.add(0)
# tree.add(1)
# tree.add(2)
# tree.add(3)
# print(tree)
# print()
# tree.breath_travel()
# print("===============")
# tree.preoder(tree.root)
# print("===============")
# tree.midoder(tree.root)
# print("===============")
# tree.postoder(tree.root)


##二叉搜索树

class Tree_search:
    def __init__(self):
        self.root = None


    def add(self,item,root):
        node = Node(item)
        if root == None:
            root = node
        if self.root == None:
            self.root = node
        elif root.item > item:
            root.lchild = self.add(item,root.lchild)
        elif root.item < item:
            root.rchild = self.add(item,root.rchild)
        return root

tree_search = Tree_search()
tree_search.add(1,tree_search.root)
tree_search.add(3,tree_search.root)
tree_search.add(4,tree_search.root)
tree_search.add(6,tree_search.root)
tree_search.add(7,tree_search.root)
print(tree_search)
print()

突然不想写了，之后会继续完善的