二叉树

• 根节点

• 叶子节点:

  • 左叶子节点

  • 右叶子节点

• 树的层级

• 树的高度

二叉树的遍历

• 广度优先遍历

  • 一层一层对节点进行遍历

• 深度优先遍历

• 前序：根左右

• 中序：左根右

• 后序：左右根

class Node():
    def __init__(self,item):
        self.item=item
        self.left=None
        self.right=None
class Tree():
    def __init__(self):
        self.root=None
    def addNode(self,item):
        node=Node(item)
        #如果插入第一个节点的情况
        if self.root==None:
            self.root=node
            return
        cur=self.root
        q=[cur]
        while q:
            nd=q.pop(0)

            if nd.left==None:
                nd.left=node
                return
            else:
                q.append(nd.left)
            if nd.right==None:
                nd.right=node
                return
            else:
                q.append(nd.right)
    def travel(self):
        cur=self.root
        q=[cur]
        while q:
            nd=q.pop(0)
            print(nd.item)
            if nd.left:
                q.append(nd.left)
            if nd.right:
                q.append(nd.right)

    def forward(self,root): #排序：根左右
        if root==None:
            return
        print(root.item)
        self.forward(root.left)
        self.forward(root.right)

    def middle(self,root): #排序：左根右
        if root==None:
            return
        self.middle(root.left)
        print(root.item)
        self.middle(root.right)

    def back(self,root): #排序：左右根
        if root==None:
            return
        self.back(root.left)
        self.back(root.right)
        print(root.item)


tree=Tree()
tree.addNode(1)
tree.addNode(2)
tree.addNode(3)
tree.addNode(4)
tree.addNode(5)
tree.addNode(6)
tree.addNode(7)
# tree.addNode(8)
# print(tree.travel())

# print(tree.forward(tree.root))
# 1 2 4 5 3 6 7

# print('>>>2',tree.middle(tree.root))

# 4 2 5 1 6 3 7

# print('>>>3',tree.back(tree.root))
# 4 5 2 6 7 3 1

排序二叉树

• 乱序数据的插入的时候，需要遵从一个准则：

• 插入的第一个数值作为树的根节点

• 后序插入的数值，如果比根节点小，插入根节点的左侧，否则插入到根节点的右侧。

class Node():
    def __init__(self,item):
        self.item=item
        self.left=None
        self.right=None
class sortTree():
    def __init__(self):
        self.root=None
    def add(self,item):
        node=Node(item)
        cur=self.root
        if self.root==None:
            self.root=node
            return
        while True:
            #向右侧插入
            if item>cur.item:
                if cur.right==None:
                    cur.right=node
                    return
                else:
                    cur=cur.right
            else: #向左插入
                if cur.left==None:
                    cur.left=node
                    return
                else:
                    cur=cur.left
    def forward(self,root): #排序：根左右
        if root==None:
            return
        print(root.item)
        self.forward(root.left)
        self.forward(root.right)

    def middle(self,root): #排序：左根右
        if root==None:
            return
        self.middle(root.left)
        print(root.item)
        self.middle(root.right)

    def back(self,root): #排序：左右根
        if root==None:
            return
        self.back(root.left)
        self.back(root.right)
        print(root.item)

tree=sortTree()
alist=[3,8,5,7,6,2,9,4,1]
for i in alist:
    tree.add(i)
print('>>>1',tree.forward(tree.root))
print('>>>2',tree.back(tree.root))
print('>>>3',tree.middle(tree.root))

二分查找

alist=[1,2,3,4,5,6,7,8,9]
def find(alist,item):
    find=False
    mid_index=len(alist)//2
    first=0
    last =len(alist)-1

    while first<last:
        mid_index=(first+last)//2
        if alist[mid_index]<item: #去中间元素的右侧继续去寻找
            first=mid_index+1
        elif alist[mid_index]>item:
            last=mid_index-1
        else:
            find=True
            break
    return find
print(find(alist,5))