数据结构------遍历二叉树的那些事

数据结构从大学学习之后，说实话忘记的差不多了，近期便在复习数据结构，刚好看到二叉树遍历这里了，想留下一下关于遍历二叉树的方法，以防楼主忘记，博文中用的语言为Swift.

创建的树TreeNode结点结构如下:

/// 树节点
class TreeNode
{
    var val : Int //数值
    var left : TreeNode?    //左子树
    var right : TreeNode?   //右子树

    init(_ val : Int)
    {
        self.val = val
        self.left = nil
        self.right = nil
    }
}

通常遍历的方法是使用递归方式遍历二叉树，但为了整合一下之前看到的栈与队列，所以也记录一下使用栈遍历数的方法:

使用栈遍历树

栈-前序

/// 用栈实现前序遍历
func preorderTraversal(root: TreeNode?) -> [Int]
{
    var res = [Int]()
    var stack = [TreeNode]()
    var node = root


    //如果栈不为空 或者 节点不是 nil
    while !stack.isEmpty || node != nil
    {
        //如果结点不为nil
        if node != nil {

            res.append(node!.val)   //数据栈中添加数据
            stack.append(node!)     //结点栈中添加结点
            node = node!.left       //指向左结点
        }else{
            //如果结点为nil,node指向最后一个根节点的右子树
            node = stack.removeLast().right
        }
    }

    return res
}

栈-中序

/// 用栈实现中序遍历
func inorderTraversal(root: TreeNode?) -> [Int]
{
    var res = [Int]()
    var stack = [TreeNode]()
    var node = root

    // 如果栈不是空 并且 结点不是nil
    while !stack.isEmpty || node != nil
    {
        //如果结点不是nil
        if node != nil
        {
            stack.append(node!)
            node = node!.left

        }else {

            //存放数据
            res.append(stack.last!.val)
            node = stack.removeLast().right
        }
    }

    return res
}

栈-后序

/// 用栈实现后序遍历
func posorderTraversal(root: TreeNode?) -> [Int]
{
    var res = [Int]()
    var stack = [TreeNode]()
    let node = root

    stack.append(node!)

    //如果栈不为空
    while !stack.isEmpty
    {
        let nodeTemp = stack.removeLast()

        res.append(nodeTemp.val)

        if nodeTemp.left != nil
        {
           stack.append(nodeTemp.left!);
        }

        if nodeTemp.right != nil
        {
            stack.append(nodeTemp.right!);
        }
    }

    return res.reversed()
}

使用递归遍历树

递归遍历算是比较无脑的一种，也是最基础的一种，这里不是说递归不好，毕竟在动态规划以及分治上还有很有作用的，写法基本一致，只是顺序不一样罢了.

/// 递归实现前序遍历
func preOrderTraversal(root: TreeNode?,_ res:inout [Int])
{
    if root != nil
    {
        res.append((root?.val)!)
        preOrderTraversal(root: root?.left,&res)
        preOrderTraversal(root: root?.right,&res)
    }
}

/// 递归实现中序遍历
func inOrderTraversal(root: TreeNode?, _ res:inout [Int])
{
    if(root != nil)
    {
        inOrderTraversal(root: root?.left, &res)
        res.append(root!.val)
        inOrderTraversal(root: root?.right, &res)
    }
}

///递归实现后序遍历
func postOrderTravelsal(root: TreeNode?, _ res:inout [Int])
{
    if root != nil {

        postOrderTravelsal(root: root?.left, &res)
        postOrderTravelsal(root: root?.right, &res)
        res.append(root!.val)
    }
}

测试

构建一棵二叉树

当然真正的构建二叉树绝对不是这么笨的办法，但仅仅是为了测试而已 , 所有请不要吐槽 = =

//初始化一棵树
var root = TreeNode(1)

//创建子树
var tree3 = TreeNode(3)
var tree8 = TreeNode(8)
var tree5 = TreeNode(5)
var tree9 = TreeNode(9)

var tree2 = TreeNode(2)
var tree7 = TreeNode(7)
var tree10 = TreeNode(10)

//拼接
tree5.right = tree9
tree3.right = tree5
tree3.left = tree8
tree7.right = tree10
tree2.right = tree7
root.left = tree3
root.right = tree2

结构如下:

1 -> 3,2
3 -> 8,5
8 -> #,#
5 -> #,9
9 -> #,#
2 -> #,7
7 -> #,10
10 -> #,#

测试结果

//进行测试
print("栈 遍历:")
print("先序:\(preorderTraversal(root: root))")
print("中序:\(inorderTraversal(root: root))")
print("后序:\(posorderTraversal(root: root))")


print("递归 遍历:")
var preOrder = [Int]()
preOrderTraversal(root: root,&preOrder)
print("先序:\(preOrder)")

var inOrder = [Int]()
inOrderTraversal(root: root, &inOrder)
print("中序:\(inOrder)")

var postOrder = [Int]()
postOrderTravelsal(root: root, &postOrder)
print("后序:\(postOrder)")

栈 遍历:
先序:[1, 3, 8, 5, 9, 2, 7, 10]
中序:[8, 3, 5, 9, 1, 2, 7, 10]
后序:[8, 9, 5, 3, 10, 7, 2, 1]
递归 遍历:
先序:[1, 3, 8, 5, 9, 2, 7, 10]
中序:[8, 3, 5, 9, 1, 2, 7, 10]
后序:[8, 9, 5, 3, 10, 7, 2, 1]
Program ended with exit code: 0