二叉树的遍历方式（内附视频讲解，各种语言的中序遍历代码实现）

二叉树之遍历方式

视频讲解：

这是博主自己的视频，谢谢大家。

二叉树的遍历方式

b站链接：
https://www.bilibili.com/video/av86745570

二叉树的性质，允许我们通过一个简单的递归算法来，按序输出二叉搜索树中的所有关键字，这种算法叫做遍历算法。
为了讲解方便，先用伪代码顶着先，然后在用具体遍历代码， 具体的遍历代码是用中序遍历算法>，因为中序遍历应用最广，面试最容易碰到。
在这里插入图片描述
那么按照顺序的不同，我们可以将遍历分为：先序、中序、后序遍历算法。

先序遍历（根的关键字在其左右子树的关键字之前）：
1.对于单个节点而言，先父节点，自己的数据，然后左节点，然后右子节点
在这里插入图片描述
2.对于单个子树或者是树而言，先根，然后左子树，右子树。（视频里面，比较清楚一点）

其实中序、先序、后序在递归的伪代码上，唯一区别就在于输出语句的位置。

中序遍历（根的关键字在其左子树的关键字和右子树的关键字之间）：
1.对于单个节点而言，先左子节点，自己，然后右子节点，最后父节点。
在这里插入图片描述
2.对于单个子树或者是树而言，先左子树，根节点，然后右子树。

后序遍历（根关键字在其左右子树的关键字之后）：

c语言的中序遍历代码实现,转载至csdn博主weixin_34302561的《二叉树中序遍历 (C语言实现)》博文，侵删：
相关链接：https://blog.csdn.net/weixin_34302561/article/details/94158413

1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <memory.h>
 4 
 5 typedef struct _tree_node{
 6     char data;
 7     struct _tree_node * left;
 8     struct _tree_node * right;
 9     struct _tree_node * father;
10 }tree_node;
11 
12 void createTree(tree_node * root);
13 void inorderTraverseTree(tree_node * pRoot);
14 
15 int main()
16 {
17     tree_node root;
18     memset(&root, 0 , sizeof(tree_node));
19     printf("Please create the tree: \n");
20     createTree(&root);
21     printf("The inorder traverse result is: \n");
22     inorderTraverseTree(&root);
23     return 0;
24 }
25 
26 //inorder traversal
27 void inorderTraverseTree(tree_node * pRoot)
28 {
29     tree_node * pCur = pRoot;
30     if(pCur != NULL)
31     {
32         if(pCur->left != NULL)
33         {
34             inorderTraverseTree(pCur->left);
35         }
36         else
37         {
38             printf("%c ", pCur->data);
39             return;
40         }
41         printf("%c ", pCur->data);
42 
43         if(pCur->right != NULL)
44         {
45             inorderTraverseTree(pCur->right);
46         }
47     }
48 }
49 
50 //Create the binary tree
51 void createTree(tree_node * pRoot)
52 {
53     char ch = 0;
54     tree_node * pCur = pRoot;
55     while((ch = getchar())!= 'e')
56     {
57         //printf("%c" , ch);
58         tree_node * pNewNode = (tree_node *)malloc(sizeof(tree_node));
59         pNewNode->left = NULL;
60         pNewNode->right = NULL;
61         pNewNode->father = NULL;
62         if(ch == 'L')
63         {
64             //printf("Input L\n");
65             pNewNode->data = getchar();
66             pNewNode->father = pCur;
67             pCur->left = pNewNode;
68             pCur = pNewNode;
69         }
70         else if(ch == 'R')
71         {
72             //printf("Input R\n");
73             pNewNode->data = getchar();
74             pNewNode->father = pCur;
75             pCur->right = pNewNode;
76             pCur = pNewNode;
77         }
78         else if(ch == 'B')
79         {
80             //printf("Input B\n");
81             free(pNewNode);
82             if(pCur->father != NULL)
83                 pCur = pCur->father;
84             else
85                 printf("It's the top\n");
86         }
87     }
88 }

JAVA的中序遍历代码实现,转载至csdn博主天黑，请闭眼的《java 中序遍历（递归、堆栈）》博文，侵删：
相关链接：https://blog.csdn.net/weixin_42706227/article/details/88728826
递归：

 //中序遍历--递归
    public void theFirstTraversal(Node n){
        if(n.getLeftNode()!=null)
            theFirstTraversal(n.getLeftNode());
        printNode(n);
        if(n.getRightNode()!=null)
            theFirstTraversal(n.getRightNode());
    }

堆栈

 //中序遍历--堆栈
    public void theFirstTraversalStack(Node root){
        Stack<Node> stack=new Stack<Node>();
        Node node=root;
        while (node!=null || stack.size()>0){
            if(node!=null){
                stack.push(node);
                node=node.getLeftNode();
            }else{
                node=stack.pop();
                printNode(node);
                node=node.getRightNode();
            }
        }
    }

Python的中序遍历代码实现,转载至csdn博主乖乖的函数的《leetcode：二叉树的中序遍历（python）》博文，侵删：
相关链接：https://blog.csdn.net/ggdhs/article/details/90812366
递归

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if root == None:
            return []
        left = self.inorderTraversal(root.left)
        right = self.inorderTraversal(root.right)
        return left + [root.val] + right

非递归

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if root == None:
            return []
        stack = []
        res = []
        temp = root
        while temp or stack:
            if temp != None:
                stack.append(temp)
                temp = temp.left
            else:
                temp = stack.pop()
                res.append(temp.val)
                temp = temp.right
        return res

参考资料：
CSDN博主翟光小朋友的《关于二叉树的前序、中序、后序三种遍历》：https://blog.csdn.net/qq_33243189/article/details/80222629
CSDN博主主乖乖的函数的《leetcode：二叉树的中序遍历（python）》：https://blog.csdn.net/ggdhs/article/details/90812366
CSDN博主天黑，请闭眼的《java 中序遍历（递归、堆栈）》：https://blog.csdn.net/weixin_42706227/article/details/88728826
CSDN博主weixin_34302561的《二叉树中序遍历 (C语言实现)》：https://blog.csdn.net/weixin_34302561/article/details/94158413
算法导论，数据结构与算法分析——C++语言描述。

来源：CSDN

作者：BTree加油鸭

链接：https://blog.csdn.net/weixin_44421437/article/details/104171113

标签

node

中序遍历

先序遍历

后序遍历