(剑指offer)27.二叉树的镜像

思路：
先前序遍历这颗树的每个节点，如果遍历到的节点有子节点，就交换它的两个子节点。当交换完所有非叶节点的左右节点之后就得到了树的镜像。

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        """递归"""
        # write code here
        if root == None:
            return
        elif root.left == None and root.right == None:
            return root
        pflog = root.left
        root.left = root.right
        root.right = pflog
        self.Mirror(root.left)
        self.Mirror(root.right)

    def preorder(self,node):
        """前序遍历"""
        if node is None:
            return
        print(node.val,end='')
        self.preorder(node.left)
        self.preorder(node.right)

    def Mirror2(self,root):
        """非递归"""
        if root ==None:
            return
        stackNode = []
        stackNode.append(root)
        while len(stackNode)>0:
            nodeNum = len(stackNode)-1
            tree = stackNode[nodeNum]
            stackNode.pop()
            nodeNum -= 1
            if tree.left != None or tree.right !=None:
                tree.left,tree.right = tree.right,tree.left
            if tree.left:
                stackNode.append(tree.left)
                nodeNum+=1
            if tree.right:
                stackNode.append(tree.right)
                nodeNum+=1



if __name__ == '__main__':
    pNode1 = TreeNode(8)
    pNode2 = TreeNode(6)
    pNode3 = TreeNode(10)
    pNode4 = TreeNode(5)
    pNode5 = TreeNode(7)
    pNode6 = TreeNode(9)
    pNode7 = TreeNode(11)

    pNode1.left = pNode2
    pNode1.right = pNode3

    pNode2.left = pNode4
    pNode2.right = pNode5

    pNode3.left = pNode6
    pNode3.right = pNode7

    s= Solution()
    s.preorder(pNode1)
    print('\n')
    # s.Mirror(pNode1)
    s.Mirror2(pNode1)
    s.preorder(pNode1)