二叉树 leetcode心得

二叉树：有两棵有顺序的子树

二叉排序树：左节点小于根节点，右节点大于根节点（左小右大）

多路查找树：每个节点可以有多个元素和大于2的孩子

平衡二叉树（AVL树）：一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树

B树（Balanced，   B-tree树）：B树的结点可以有很多孩子，是平衡的多路查找树（加快查找效率）

                      用途：用在磁盘文件组织 数据索引和数据库索引。降低磁盘I/O操作

                     原理:B树的一个节点就是内存一次性读取的内容,然后内存里只要储存有根节点，我们就可以查找到所有的元素，

 

B+树：把上一层的节点元素同时复制在了下一层，

                   用途：大多数的磁盘文件系统和一些数据库比如mysql就使用了B+树进行索引，为了解决B树不好处理所有元素遍历等基本问题（效率低，多次遍历同一个元素）

                  原理：把上一层的节点元素同时复制在了下一层，同层间用指针域连接成为排序好的序列，遍历和寻找某一范围的树就效率高了。

Trie树(字典树):统计和排序大量字符串，如自动机。

红黑树: 平衡二叉树，广泛用在C++的STL中。如map和set都是用红黑树实现的。

 

class Node(object):
    def __init__(self,root):
        self.value=root
        self.left=None
        self.right=None

class Solution(object):   #判断二叉树深度  n-1/1递归法+递归赋值
    def howhigh(self,root):
        return max(self.howhigh(root.left),self.howhigh(root.right))+1

    def BST(self,root):    #验证二叉树，利用中序思想
        result=[]
        self.zhongxv(root,result)
        for i in range(len(result)-1):
            if result[i]>result[i+1]:     
                return False   #此处不可颠倒，必须是逆向思维，只考虑前面大于后面失败的情形，成功的情形太多
        return True

     def zhongxv(self,root,result):  #中序搜索，常规递归
         if not root:
             return
         self.zhongxv(root.left,result)
         result.append(root.val)
         self.zhongxv(root.right,result)
         return result

     def isSym(self,root):   #判断对称二叉树
         if not root:
             return True
         return self.judge(root.left,root.right)

     def judge(self,left,right):    #n-1/1递归法
         if not left and not right:
             return True
         if left and right and left.val==right.val:
             return judge(left.left,right.right)  and judge(left.right,right.left)
         return False

     def travel(self,root):    #二叉树层次遍历  ,利用列表删添操作
         tmp=[root]
         result=[]
         while tmp:
             p=[]
             for i in range(len(tmp)):
                 a=tmp.pop(0)
                 p.append(a)
                 if root.left:
                     tmp.append(root.left)
                 if root.right:
                     tmp.append(root.right)
             result.append(p)
         return result

     def zhuanhuan(self,nums):  #将列表转换为二叉搜索树
         n=len(nums)
         mid=n//2
         if not nums:
             return None
         root=Node(nums[mid])
         root.left=self.zhuanhuan(nums[:mid])
         root.right=self.zhuanhuan(nums[mid+1:])
         return root

 

 

 

 

深度优先有三种算法：前序遍历，中序遍历，后序遍历

 

 

广度优先(层次遍历):

def breadth_travel(self, root):
        """利用队列实现树的层次遍历"""
        if root == None:
            return
        queue = [root]
        result=[]
        while queue:
            node = queue.pop(0)
            result.append(node)
            if node.lchild != None:
                queue.append(node.lchild)
            if node.rchild != None:
                queue.append(node.rchild)
         return result

 

树：

1.二叉搜索树(又称有序二叉树)        性质1.（左叉小于右叉，因此，以root为中心，左边所有的数小于右边所有的数，一定是二叉树）------用来将有序数组，变化成二叉搜索树（递归）

-----性质2.（左叉一定小于右叉，且数为整型变量），用来判断是否为二叉搜索树.

2.二叉树层次遍历（相当于数组堆的过程，后入先出，依次加入堆中）（队列）-----用来遍历树

3.对称二叉树定义（有左叉一定有右叉）-------用来判断是否为对称二叉树（递归）

 

链表：

1.链表由指针和值构成的-------性质1（删除某节点，要改变指向它的指针和该指针指向的值）

2.头结点不存放数据，只是为了方便链表的操作。----