二叉树及其遍历

最近看了一些二叉树的知识 ,搞得人头晕,先看两篇博客:

二叉树基础知识
上一段python递归实现二叉树遍历的代码:

# -*- coding: utf-8 -*-


class node(object):
    def __init__(self, data=None, left=None, right=None):
        self.data = data
        self.left = left
        self.right = right


# 深度
def depth(tree):
    if tree == None:
        return 0
    left, right = depth(tree.left), depth(tree.right)
    return max(left, right) + 1


# 前序遍历
def pre_order(tree):
    if tree == None:
        return
    print(tree.data)
    pre_order(tree.left)
    pre_order(tree.right)


# 中序遍历
def mid_order(tree):
    if tree == None:
        return
    mid_order(tree.left)
    print(tree.data)
    mid_order(tree.right)


# 后序遍历
def post_order(tree):
    if tree == None:
        return
    post_order(tree.left)
    post_order(tree.right)
    print(tree.data)


# 层次遍历
def level_order(tree):
    if tree == None:
        return
    q = []
    q.append(tree)
    while q:
        current = q.pop(0)
        print
        current.data
        if current.left != None:
            q.append(current.left)
        if current.right != None:
            q.append(current.right)


# 按层次打印
def level2_order(tree):
    if tree == None:
        return
    q = []
    q.append(tree)
    results = {}
    level = 0
    current_level_num = 1
    nextlevelnum = 0
    d = []
    while q:
        current = q.pop(0)
        current_level_num -= 1
        d.append(current.data)
        if current.left != None:
            q.append(current.left)
            nextlevelnum += 1
        if current.right != None:
            q.append(current.right)
            nextlevelnum += 1
        if current_level_num == 0:
            current_level_num = nextlevelnum
            nextlevelnum = 0
            results[level] = d
            d = []
            level += 1
    print(results)


if __name__ == '__main__':
    tree = node('A', node('B', node('D'), node('F',left=node('E'))), node('C',node('G',right=node('H')),node('I') ))
    print( '前序遍历：')
    pre_order(tree)
    print('\n')
    print('中序遍历：')
    mid_order(tree)
    print('\n')
    print ('后序遍历：')
    post_order(tree)
    print('\n')
    print("层次遍历")
    level2_order(tree)

结果测试是对的,其实主要看遍历的方式就可以了,比如前序遍历是根左右的形式,所以第一个是根,所以先print,再递归.
然后就是一个有趣的题目:

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。
假设输入的数组的任意两个数字都互不相同。

思路如下:

二叉搜索树的特性是,其左子树都小于根节点,右子树都大于跟节点.又是后序遍历(左右根),则最后一个元素是根节点,
序列第一个比根节点大的数之前都是左子树,判断右子树是不是都比根节点大,若大,就把左右子树提出来,进行递归.

代码如下:

# -*- coding:utf-8 -*-
class Solution:
    def VerifySquenceOfBST(self, sequence):
        # write code here
        if not sequence:
            return False
        if len(sequence)==1:
            return True
        length=len(sequence)
        root=sequence[-1]
        i=0
        while  sequence[i]<root:
            i=i+1
        k=i
        for j in range(i, length-1):
            if sequence[j] < root:
                return False
        left_s = sequence[:k]
        right_s = sequence[k:length-1]

        leftIs = True
        rightIs = True

        if len(left_s) > 0:
            leftIs = self.VerifySquenceOfBST(sequence=left_s)
        if len(right_s) > 0:
            rightIs = self.VerifySquenceOfBST(sequence=right_s)

        return leftIs and rightIs
        # write code here

猜你喜欢