二叉搜索树de遍历

题目描述：给定一颗二叉搜索树，请找出其中的第k大的结点。例如， 5 / \ 3 7 /\ /\ 2 4 6 8 中，按结点数值大小顺序第三个结点的值为4。

思路：首先看见这道题，中序遍历可以很好地解决这个问题,剑指offer中的C++代码变换时，不知道Python怎么定义参数传递，后来请教大佬才知道，定义一个只有单个元素的列表就可以。

class Solution:
    # 返回对应节点TreeNode
    def KthNode(self, pRoot, k):
        # write code here
        if (not pRoot) or (k==0):
            return None
        target,_ =self.knode(pRoot, k)
        return target
    def knode(self, pRoot, k):
        target = None
        node_num = 0
        if  pRoot.left != None:
            target, num = self.knode(pRoot.left, k)
            node_num += num
        if target == None:
            if k-node_num == 1:
                target = pRoot
            node_num += 1
            k-=node_num
        if target == None and pRoot.right!=None:
            target,num = self.knode(pRoot.right, k)
            node_num += num
        return target,node_num

定义列表的解法，思想一样的

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回对应节点TreeNode
    def KthNode(self, pRoot, k):
        # write code here
        if (not pRoot) or (k==0):
            return None
        L = []
        L.append(k)
        target =self.knode(pRoot, L)
        return target
    def knode(self, pRoot, L):
        target = None
        if  pRoot.left != None:
            target = self.knode(pRoot.left, L)
        if target == None:
            if L[0] == 1:
                target = pRoot
            L[0]-=1
        if target == None and pRoot.right!=None:
            target = self.knode(pRoot.right, L)
        return target

2 平衡二叉树

题目描述

输入一棵二叉树，判断该二叉树是否是平衡二叉树。主要是进行后序遍历

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def IsBalanced_Solution(self, pRoot):
        # write code here
        if pRoot is None:
            return True
        left = self.depth(pRoot.left)
        right = self.depth(pRoot.right)
        diff = left - right
        if diff ==1 or diff == -1 or diff==0:
            return self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.right)
        else:
            return False
    def depth(self, pRoot):
        if pRoot is None:
            return 0
        left = self.depth(pRoot.left)
        right = self.depth(pRoot.right)
        if left > right:
            return left+1
        else:
            return right+1