leetcode面试二叉树的层序遍历

最新推荐文章于 2024-02-16 14:30:00 发布

原创最新推荐文章于 2024-02-16 14:30:00 发布 · 115 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#go #二叉树

二叉树专栏收录该内容

15 篇文章

订阅专栏

这篇博客介绍了一种利用循环队列进行二叉树层次遍历的方法。首先定义了一个MyCircularQueue结构体，实现了EnQueue、DeQueue、Front、Rear、IsEmpty和IsFull等操作。接着，利用这个循环队列实现层次遍历，通过EnQueue将根节点入队，然后不断出队并入队子节点，直至队列为空，返回层次遍历的结果。层次遍历能有效地展示二叉树每一层的节点分布情况。

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


func Constructor(k int) MyCircularQueue {
    return MyCircularQueue{
        Parr: make([]*TreeNode, k),
        Head: 0,
        Tail: 0,
        Length: k,
        Cap: 0,
    }
}


func (this *MyCircularQueue) EnQueue(value *TreeNode) bool {
    if this.Head == this.Tail && this.Cap > 0{
        return false
    }

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

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

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


func (this *MyCircularQueue) DeQueue() bool {
    if this.Head == this.Tail && this.Cap == 0 {
        return false
    }

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

    this.Cap = this.Cap - 1

    return true
}


func (this *MyCircularQueue) Front() *TreeNode {
    if this.IsEmpty() {
        return nil
    }
    return this.Parr[this.Head]
}


func (this *MyCircularQueue) Rear() *TreeNode {
    if this.IsEmpty() {
        return nil
    }

    index := (this.Tail - 1 + this.Length) % this.Length
    return this.Parr[index]
}


func (this *MyCircularQueue) IsEmpty() bool {
    if this.Tail == this.Head && this.Cap == 0{
        return true
    }else {
        return false
    }
}


func (this *MyCircularQueue) IsFull() bool {
    if this.Head == this.Tail && this.Cap > 0{
        return true
    }else {
        return false
    }
}

func levelOrder(root *TreeNode) [][]int {
    cirQueue := Constructor(1000)
    rsp := make([][]int, 0)
    if nil == root {
        return rsp
    }

    cirQueue.EnQueue(root)

    for ; !cirQueue.IsEmpty(); {
        size := cirQueue.Cap
        tempSlict := make([]int, 0)
        for i := 0; i < size; i = i + 1 {
            
            node := cirQueue.Front()

            tempSlict = append(tempSlict, node.Val)

            cirQueue.DeQueue()

            if node.Left != nil {
                cirQueue.EnQueue(node.Left)
            }

            if node.Right != nil {
                cirQueue.EnQueue(node.Right)
            }

            
        }
        rsp = append(rsp, tempSlict)

    } 
    return rsp
}