leetcode判断是否二叉镜像树迭代实现

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
type MyCirQueue struct {
    Parr []*TreeNode
    Head int
    Tail int
    Cap  int
    Size int
}

func QueueConstructor(k int) MyCirQueue {
    return MyCirQueue{
        Parr: make([]*TreeNode, k),
        Head: 0,
        Tail: 0,
        Cap: k,
        Size: 0,
    }
}

func(this *MyCirQueue) EnQueue(val *TreeNode) bool{
   if this.IsFull() == true {
       return false
   }

   this.Parr[this.Tail] = val
   this.Tail = this.Tail + 1

   if this.Tail == this.Cap {
       this.Tail = 0
   }

    this.Size = this.Size + 1
   return true
}

func(this *MyCirQueue) IsEmpty() bool {
    if this.Head == this.Tail && this.Size == 0 {
        return true
    } 

    return false
}

func(this *MyCirQueue) IsFull() bool {
    if this.Head == this.Tail && this.Size != 0 {
        return true
    } 

    return false
}

func(this *MyCirQueue)DeQueue() bool {
    if this.IsEmpty() {
        return false
    }

    this.Head = this.Head + 1
    if this.Head == this.Cap {
        this.Head = 0
    }

    this.Size = this.Size - 1
    return true
}

func (this* MyCirQueue)Front()*TreeNode{
    if this.IsEmpty(){
        return nil
    }

    return this.Parr[this.Head]
}

func isSymmetric(root *TreeNode) bool {
    if nil == root {
        return true
    }

    queue := QueueConstructor(1000)
    queue.EnQueue(root)
    queue.EnQueue(root)

    for ; !queue.IsEmpty(); {
        v := queue.Front()
        queue.DeQueue()
        u := queue.Front()
        queue.DeQueue()

        if v == nil && u == nil {
            continue
        }

        if v == nil || u == nil || v.Val != u.Val {  
            return false
        }

        //fmt.Println(v.Val, u.Val)
        queue.EnQueue(v.Left)
        queue.EnQueue(u.Right)

        queue.EnQueue(v.Right)
        queue.EnQueue(u.Left)
    }

    return true
}