算法基础 01

算法基础（一）

最近俩天学习了很多算法,很感兴趣 所以准备长期更新下去标题 有时会学习下英语单词 学习高数 所以日期不定
写者目的 供回忆复习使用 很多基础内容请看专业书籍记忆

很多算法 如常规算法 汉诺塔 二分查找 线性查找 冒泡排序 快速排序 创建堆 堆排 插入 插入排序 希尔排序 计数排序 基数排序 桶排序 线性二叉树排序 括号 迷宫深度搜索 迷宫广度搜索 等等不多详讲 很容易学会
下面讲一个AVL树的写法

AVL 需要了解二叉树 见 AVL树百度百科

class AVLTree(BSTTree):
    def __init__(self,li=None):
        BSTTree.__init__(self,li)
    #右右左旋
    #即 s2 属于p   p属于c
    def rotote_left(self,p,c):
        s2 =c.lchild;
        p.rchild=s2
        if s2:
            s2.parent=p
        c.lchild=p
        p.parent=c

        #更新bf

        p.bf = 0
        c.bf = 0
        return c

    def rotote_right(self,p,c):
        s2=c.rchild
        p.lchild=s2
        if s2:
            s2.parent=p
        c.rchild=p
        p.parent=c

        #更新bf

        p.bf=0
        c.bf=0
        return c
    def rotote_right_left(self,p,c):
        g=c.lchild

        s3=g.rchild
        c.lchild=s3
        if s3:
            s3.parent=c
        g.rchild =c
        c.parent=g

        s2=g.lchild
        p.rchild=s2
        if s2:
            s2.parent=p
        g.lchild=p
        p.parnent=g

        #更新bf
        if g.bf>0:
            c.bf=0
            p.bf=-1
        elif g.bf<0:
            c.bf=1
            p.bf=0
        else:
            p.bf=0
            c.bf=0
        return g
    #
    def rotote_left_right(self,p,c):
        g=c.rchild

        s2=g.lchild
        c.rchild=s2
        if s2:
            s2.parent=c

        s3=g.rchild
        p.lchild=s3
        if s3:
            s3.parent=p

        g.rchild=p
        p.parent=g
        g.lchild=c
        c.parent=g

        #更新bf
        if g.bf>0:
            p.bf=0
            c.bf=-1
        elif g.bf<0:
            p.bf=1
            c.bf=0
        else:
            p.bf=0
            c.bf=0
        return g
    def insert_no_rec(self,val):

        p = self.root  #初始为搜索二叉树树
        if not p:
            self.root = AVLNode(val)
            return
        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild  #持续遍历
                else:
                    p.lchild = AVLNode(val)  #符合条件创建
                    p.lchild.parent = p   #连接父节点

                    node=p.lchild  #保存生成的p
                    break
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:
                    p.rchild = AVLNode(val)
                    p.rchild.parent = p
                    node=p.lchild  #保存生成的p
                    break
            else:
                return  #不允许插入相同的值
        #接下来循环遍历
        print("进入")
        self.mid_order(self.root)
        while node.parent:
            if node.parent.lchild==node: #判断是从哪个树插入的  左边  即有 左左 （右旋）  左右 (左旋右旋)
                g = node.parent.parent
                primitiveNode = node.parent
                if node.parent.bf<0:
                    if node.bf>0:
                        n=self.rotote_left_right(node.parent,node)
                        break
                    else:
                        n=self.rotote_right(node.parent,node)
                elif node.parent.bf>0:
                    node.parent.bf=0
                    break
                else:
                    node.parent.bf=-1
                    node=node.parent
                    continue
            else:
                if node.parent.bf>0:
                    g = node.parent.parent
                    primitiveNode = node.parent
                    if node.bf>0:
                        n=self.rotote_left(node.parent,node)
                    else:
                        n=self.rotote_right_left(node.parent,node)
                elif node.parent.bf<0:
                    node.parent.bf=0
                    break
                else:
                    node.parent.bf=1
                    node=node.parent
                    continue
            n.parent=g
            if not g:
                self.root=n
                return
            if g.lchild==primitiveNode:
                g.lchild=node
                break
            else:
                g.rchild=node
                break

大致的内容:
AVL树插入 搜索树的插入规则 结合 左旋 右旋 左右旋 右左旋
形成
bf是AVL树重要表现形式 我们可以自定义balanced factor bf 如 右树每有一层为正数 左树每有一层为负数 相加即为bf
只要是AVL树 其balanced factor总是不大于1 或者小于-1