二叉树填充每个节点的下一个右侧节点指针

/**
 * Definition for a Node.
 * type Node struct {
 *     Val int
 *     Left *Node
 *     Right *Node
 *     Next *Node
 * }
 */
type CircleQueue struct {
    Buff [4096]*Node
    Cap  int
    Length int
    Start int
    End int
}

func (p *CircleQueue) Capacity() int {
    return len(p.Buff)
}

func (p *CircleQueue) IsEmpty() bool {
    if p.Start == p.End && p.Length == 0 {
        return true
    }

    return false
}

func (p *CircleQueue) Push(val *Node) error {
    if p.Start == p.End && p.Length != 0 {
        return errors.New("circle queue is full")
    }

    p.Buff[p.Start] = val
    p.Start = p.Start + 1

    if p.Start == p.Cap {
        p.Start = 0
    }

    p.Length = p.Length + 1

    return nil
}

func(p *CircleQueue)Pop()(err error, val *Node) {
    val = nil

    if p.Start == p.End && p.Length == 0 {
        return errors.New("circle queue is empty"), val
    }

    val = p.Buff[p.End]
    p.End = p.End + 1
    
    if p.End == p.Cap {
        p.End = 0
    }

    p.Length = p.Length - 1

    return nil, val
}


func connect(root *Node) *Node {
	queue := CircleQueue{}

    if nil == root {
        return nil
    }

    queue.Push(root)
    //level := 1

    for ; !queue.IsEmpty(); {
        i := queue.Length
        temp := make([]*Node, 0)
        for j := 0; j < i; j = j + 1 {
            _, node1 := queue.Pop()
            temp = append(temp, node1)
            if node1.Left != nil {
                queue.Push(node1.Left)
            }

            if node1.Right != nil {
                queue.Push(node1.Right)
            }
        }

        for k := 0; k < len(temp); k++ {
            if k == len(temp) - 1 {
                temp[k].Next = nil
            }else {
                temp[k].Next = temp[k + 1]
            }
        }
    }

    return root
}