二叉树层次遍历python_二叉树 队列 数组 层次遍历

bfs 和 队列

学过数据结构的都知道，二叉树的层次遍历。

层次遍历利用的数据结构是队列。

那么，

思考一下

为什么层次遍历，要用到队列，而不是其他的数据结构，比如栈呢？换句话说，队列在二叉树的层次遍历过程中起到了什么作用呢？

队列在二叉树层次遍历中的作用

我们知道，二叉树的结构如下:

/**

* Definition for a binary tree node.

* type TreeNode struct {

* Val int

* Left *TreeNode

* Right *TreeNode

* }

*/

从结构中大致可以知道，二叉树的根跟左右还是是采用链表的形式联系的，父节点，保存了左右孩子的指针，所以，我们知道了父节点，必然也就知道了左右孩子的信息。

但是，在一个二叉树中，同层之间的信息通过什么联系在一起的呢？

7

5 8

2 6 9 12

比如上图中的2，6，9，12，这时层次遍历的时候，我们如何保持同层之间的顺序呢？这个就应该是靠队列的作用了。

队列的一个特点是，元素是先进先出，我们可以把同层的兄弟元素依次入队，然后，在出队的过程中再遍历左右孩子，循环以上操作即可。

通过数组创建二叉树vs二叉树的层次遍历

今天，做leetcode上的一道二叉树层次遍历的题目，由于需要在本地调试，所以想在本地创建一个二叉树，于是想到了，通过数组去创建一个二叉树，也就是将一个数组转化为完全二叉树。

最后发现，原来，通过数组创建二叉树和二叉树的层次遍历其实存在着某种联系，他们是一个相反的过程。

也就是通过数组创建二叉树是将数组转化为二叉树，而二叉树的层次遍历其实是将二叉树转化为数组的形式。

确实很妙。

下面给出代码

python

#!/usr/bin/python

#-*- coding: UTF-8 -*-

class node():

def __init__(self,k=None,l=None,r=None):

self.key=k;

self.left=l;

self.right=r;

def create_tree_by_array(input_list):

"""

通过数组创建二叉树，

其实是层次遍历

需要利用节点队列

"""

def _createNode(item):

if item is '#':

return None

else:

return node(k=item)

queue = []

root = _createNode(input_list.pop(0))

queue.append(root)

while len(input_list) > 0:

curNode = queue.pop(0)

curNode.left = _createNode(input_list.pop(0))

curNode.right = _createNode(input_list.pop(0))

if curNode.left:

queue.append(curNode.left)

if curNode.right:

queue.append(curNode.right)

return root

def traverse_tree_by_level(root):

"""

层次遍历

需要利用节点队列

"""

queue = []

output_list = []

queue.append(root)

output_list.append(root.key)

while len(queue) > 0:

curNode = queue.pop(0)

if curNode.left:

output_list.append(curNode.left.key)

queue.append(curNode.left)

if curNode.right:

output_list.append(curNode.right.key)

queue.append(curNode.right)

print(output_list)

def inorder(root): #中序遍历

if root is None:

return ;

else:

inorder(root.left);

print(root.key,)

inorder(root.right);

tree_data_list = [3,9, 20, '#','#', 15,7]

root=None; # 测试代码

root=create_tree_by_array(tree_data_list);

inorder(root);

traverse_tree_by_level(root)

golang

package main

import (

"fmt"

)

type Node struct {

Value int

Left *Node

Right *Node

}

func CreateNode(item int) *Node {

if item == -1 {

return nil

}

return &Node{item, nil, nil}

}

func CreateByBreadthFirstSearch(inputList []int) *Node {

queue := []*Node{}

root := CreateNode(inputList[0])

queue = append(queue, root)

inputList = inputList[1:]

for len(inputList) > 0 {

curNode := queue[0]

queue = queue[1:]

curNode.Left = CreateNode(inputList[0])

if curNode.Left != nil {

queue = append(queue, curNode.Left)

}

inputList = inputList[1:]

curNode.Right = CreateNode(inputList[0])

if curNode.Right != nil {

queue = append(queue, curNode.Right)

}

inputList = inputList[1:]

}

return root

}

func (node *Node) BreadthFirstSearch() {

if node == nil {

return

}

output_list := []int{}

queue := []*Node{node}

for len(queue) > 0 {

curNode := queue[0]

queue = queue[1:]

output_list = append(output_list, curNode.Value)

if curNode.Left != nil {

queue = append(queue, curNode.Left)

}

if curNode.Right != nil {

queue = append(queue, curNode.Right)

}

}

for _, v := range output_list {

fmt.Print(v, " ")

}

}

func main() {

input_list := []int{3, 7, 9, -1, -1, 20, 4}

root := CreateByBreadthFirstSearch(input_list)

root.BreadthFirstSearch()

}