【数据结构与算法】二叉树的遍历

前序遍历是指，对于树中的任意节点来说，先打印这个节点，然后再打印它的左子树，最后打印它的右子树。

中序遍历是指，对于树中的任意节点来说，先打印它的左子树，然后再打印它本身，最后打印它的右子树。

后序遍历是指，对于树中的任意节点来说，先打印它的左子树，然后再打印它的右子树，最后打印这个节点本身。

层次遍历是指，对树中的节点一层一层的打印，其实就是广度优先算法(BFS)。

一、前序遍历

LeetCode: https://leetcode-cn.com/problems/binary-tree-preorder-traversal/

C语言代码实现：

  1 /**
  2  * Definition for a binary tree node.
  3  * struct TreeNode {
  4  *     int val;
  5  *     struct TreeNode *left;
  6  *     struct TreeNode *right;
  7  * };
  8  */
  9 
 10 
 11 /**
 12  * Note: The returned array must be malloced, assume caller calls free().
 13  */
 14 
 15 /* 获取树的节点个数 */
 16 int getTreeNodeLen(struct TreeNode* root)
 17 {
 18     if (root == NULL) {
 19         return 0;
 20     }
 21     return 1 + getTreeNodeLen(root->left) + getTreeNodeLen(root->right);
 22 }
 23 
 24 /* 树的前序遍历: 递归 */
 25 void preorder(struct TreeNode *root, int *returnSize, int *result)
 26 {
 27     if (root == NULL) {
 28         return;
 29     }
 30     result[*returnSize] = root->val;
 31     (*returnSize)++;
 32     preorder(root->left, returnSize, result);
 33     preorder(root->right, returnSize, result);
 34     return;
 35 }
 36 
 37 int* preorderTraversal(struct TreeNode *root, int *returnSize){
 38     (*returnSize) = 0;
 39     int len = getTreeNodeLen(root);
 40     if (len == 0) {
 41         return NULL;
 42     }
 43     
 44     int *result = (int *)malloc(len * sizeof(int));
 45     if (result == NULL) {
 46         return NULL;
 47     }
 48     /************* 递归实现 **************/
 49     //preorder(root, returnSize, result);
 50     
 51     
 52     /**********  非递归实现的第一种方法 ************************/
 53     /*
 54     struct TreeNode **stacks = (struct TreeNode **)malloc(len * sizeof(struct TreeNode *));
 55     if (stacks == NULL) {
 56         return NULL;
 57     }
 58     int top = -1; 
 59     stacks[++top] = root;
 60     struct TreeNode *tmp = NULL;
 61     //int i = 0;
 62     while (top != -1) {
 63         tmp = stacks[top--];
 64         result[*returnSize] = tmp->val;
 65         // printf("result:%d ", tmp->val);
 66         (*returnSize)++;
 67         
 68         if (tmp->right) {
 69             stacks[++top] = tmp->right;
 70             // printf("right:%d
", tmp->right->val);
 71         }  
 72         if (tmp->left) {
 73             stacks[++top] = tmp->left;
 74             // printf("left:%d ", tmp->left->val);
 75         }
 76 
 77     }
 78     free(stacks);
 79     stacks = NULL;
 80     */
 81     
 82     /******** 非递归实现的第二种方法  **********/
 83     struct TreeNode **stacks = (struct TreeNode **)malloc(len * sizeof(struct TreeNode *));
 84     if (stacks == NULL) {
 85         return NULL;
 86     }
 87     int top = -1; 
 88     struct TreeNode *tmp = root;
 89     int i = 0;
 90     while (tmp != NULL || top != -1) {
 91         if (tmp != NULL) {
 92             result[i++] = tmp->val;
 93             stacks[++top] = tmp;
 94             tmp = tmp->left;
 95         } else {
 96             tmp =  stacks[top--];
 97             tmp = tmp->right;
 98         }
 99     }
100     free(stacks);
101     stacks = NULL;
102     (*returnSize) = i;
103     return result;
104 }

View Code

二、中序遍历

LeetCode: https://leetcode-cn.com/problems/binary-tree-inorder-traversal/

C语言代码实现：

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     struct TreeNode *left;
 6  *     struct TreeNode *right;
 7  * };
 8  */
 9 
10 
11 /**
12  * Note: The returned array must be malloced, assume caller calls free().
13  */
14 
15 int getTreeNodeLen(struct TreeNode* root)
16 {
17     if (root == NULL) {
18         return 0;
19     }
20     return 1 + getTreeNodeLen(root->left) + getTreeNodeLen(root->right);
21 }
22 
23 void inorder(struct TreeNode* root, int* returnSize, int *result)
24 {
25     if (root == NULL) {
26         return;
27     }
28     inorder(root->left, returnSize, result);
29     result[*returnSize] = root->val;
30     (*returnSize)++;
31     inorder(root->right, returnSize, result);
32     return;
33 }
34 
35 int* inorderTraversal(struct TreeNode* root, int* returnSize){
36     int len = getTreeNodeLen(root);
37     (*returnSize) = 0;
38     if (len == 0) {
39         return NULL;
40     }
41     
42     int *result = (int *)malloc(len * sizeof(int));
43     if (result == NULL) {
44         return NULL;
45     }
46     /* 方法一: 递归 */
47     //inorder(root, returnSize, result);
48     
49     /* 方法二: 非递归 */
50     struct TreeNode **stacks = (struct TreeNode**)malloc(len * sizeof(struct TreeNode *));
51     if (stacks == NULL) {
52         return NULL;
53     }
54     int top = -1;
55     struct TreeNode* tmp = root;
56     int i = 0;
57     while (tmp != NULL || top != -1) {
58         if (tmp) {
59             stacks[++top] = tmp;
60             tmp = tmp->left;
61         } else {
62             tmp = stacks[top--];
63             result[i++] = tmp->val;
64             tmp = tmp->right;
65         }
66     }
67     (*returnSize) = i;
68     free(stacks);
69     stacks = NULL;
70     
71     return result;
72 }

View Code

三、后序遍历

LeetCode: https://leetcode-cn.com/problems/binary-tree-postorder-traversal/submissions/

C语言代码实现：

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     struct TreeNode *left;
 6  *     struct TreeNode *right;
 7  * };
 8  */
 9 
10 
11 /**
12  * Note: The returned array must be malloced, assume caller calls free().
13  */
14 
15 int getTreeNodeLen(struct TreeNode* root)
16 {
17     if (root == NULL) {
18         return 0;
19     }
20     return 1 + getTreeNodeLen(root->left) + getTreeNodeLen(root->right);
21 }
22 
23 void postOrder(struct TreeNode* root, int* returnSize, int *result)
24 {
25     if (root == NULL) {
26         return;
27     }
28     postOrder(root->left, returnSize, result);
29     postOrder(root->right, returnSize, result);
30     result[*returnSize] = root->val;
31     (*returnSize)++;
32     return;
33 }
34 
35 int* postorderTraversal(struct TreeNode* root, int* returnSize){
36     int len = getTreeNodeLen(root);
37     (*returnSize) = 0;
38     if (len == 0) {
39         return NULL;
40     }
41     
42     int *result = (int *)malloc(len * sizeof(int));
43     if (result == NULL) {
44         return NULL;
45     }
46     
47     /* 递归实现 */
48     //postOrder(root, returnSize, result);
49     
50     // 非递归实现 
51     struct TreeNode **stacks = (struct TreeNode **)malloc(len * sizeof(struct TreeNode *));
52     if (stacks == NULL) {
53         return NULL;
54     }
55     int top = -1;
56     struct TreeNode * tmp = root;
57     int i = 0;
58     struct TreeNode * prev = NULL;
59     struct TreeNode * topNode = NULL;
60     while (tmp != NULL || top != -1) {
61         // 先把所有的左孩子入栈，到叶子节点为止
62         if (tmp) {
63             stacks[++top] = tmp;
64             //printf("left: tmp:%d
", tmp->val);
65             tmp = tmp->left;
66         } else {
67             topNode = stacks[top];
68             //printf("topNode: %d
", topNode->val);
69             if (topNode->right == NULL || prev == topNode->right) { /* 如果右孩子为空，或者上一次遍历的是右孩子。直接将该节点输出 */
70                 result[i++] = topNode->val;
71                 prev = topNode;
72                 top--;
73             } else { /* 有右孩子并且还没访问，将当前节点置为右孩子 */
74                 tmp = topNode->right;
75             }
76         }
77     }
78     //printf("i:%d
", i);
79     (*returnSize) = i;
80     return result;
81 }

View Code

四、层次遍历

LeetCode: https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

C语言代码实现：

  1 /**
  2  * Definition for a binary tree node.
  3  * struct TreeNode {
  4  *     int val;
  5  *     struct TreeNode *left;
  6  *     struct TreeNode *right;
  7  * };
  8  */
  9 
 10 
 11 /**
 12  * Return an array of arrays of size *returnSize.
 13  * The sizes of the arrays are returned as *returnColumnSizes array.
 14  * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 15  */
 16 
 17 int getTreeNodeLen(struct TreeNode* root)
 18 {
 19     if (root == NULL) {
 20         return 0;
 21     }
 22     return 1 + getTreeNodeLen(root->left) + getTreeNodeLen(root->right);
 23 }
 24 
 25 void helper(struct TreeNode* root, int** result, int* ColumnSizes, int i, int* maxh) {
 26     if (root != NULL) {
 27         result[i][ColumnSizes[i]] = root->val;
 28         ColumnSizes[i]++;
 29         if(i+1>*maxh)
 30             *maxh = i+1;
 31         helper(root->left, result, ColumnSizes, i + 1, maxh);
 32         helper(root->right, result, ColumnSizes, i + 1, maxh);
 33     }
 34 }
 35 
 36 int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
 37     (*returnSize) = 0;
 38     int len = getTreeNodeLen(root);
 39     if (len == 0) {
 40         return NULL;
 41     }
 42     int **result = (int **)malloc(sizeof(int *) * len);
 43     for (int i = 0; i < len; i++) {
 44         result[i] = (int *)malloc(len * sizeof(int));
 45     }
 46     *returnColumnSizes = (int*)calloc(len, sizeof(int));
 47     // 递归实现
 48     helper(root, result, *returnColumnSizes, 0, returnSize);
 49     return result;
 50     
 51     
 52     // 非递归实现
 53     /*
 54     (*returnSize) = 0;
 55     int len = getTreeNodeLen(root);
 56     if (len == 0) {
 57         return NULL;
 58     }
 59     (*returnColumnSizes) = (int *)malloc(len * sizeof(int));
 60     int **result = (int **)malloc(len * sizeof(int *));
 61     if (result == NULL) {
 62         return NULL;
 63     }
 64     
 65     struct TreeNode **queue = (struct TreeNode **)malloc(len * sizeof(struct TreeNode *));
 66     if (queue == NULL) {
 67         return NULL;
 68     }
 69     
 70     
 71     int front = 0;
 72     int back = 0;
 73     int i;
 74     struct TreeNode * tmp = NULL;
 75     
 76     queue[back++] = root;
 77     result[0] = (int*)malloc(sizeof(int));
 78     result[0][0] = root->val;
 79     (*returnColumnSizes)[0] = 1;
 80     i = 1;
 81     while (front != back) {
 82         tmp = queue[front];
 83         printf("entry: front:%d, back:%d
", front, back);
 84         printf("queue: %d
", tmp->val);
 85         if (tmp->left && tmp->right) {
 86             result[i] = (int*)malloc(2 * sizeof(int));
 87             result[i][0] = tmp->left->val;
 88             result[i][1] = tmp->right->val;
 89             printf("both: result[%d][0]:%d,  result[%d][1]:%d
", i, result[i][0], i, result[i][1]);
 90             queue[back++] = tmp->left;
 91             queue[back++] = tmp->right;
 92             (*returnColumnSizes)[i] = 2;
 93             i++;
 94             printf("front:%d, back:%d
", front, back);
 95         } else if (tmp->left) {
 96             result[i] = (int *)malloc(sizeof(int));
 97             result[i][0] = tmp->left->val;
 98             printf("left: result[%d][0]:%d
", i, result[i][0]);
 99             queue[back++] = tmp->left;
100             (*returnColumnSizes)[i] = 1;
101             i++;
102             printf("left: front:%d, back:%d
", front, back);
103         } else if (tmp->right) {
104             result[i] = (int *)malloc(sizeof(int));
105             result[i][0] = tmp->right->val;
106             printf("right: result[%d][0]:%d
", i, result[i][0]);
107             queue[back++] = tmp->right;
108             (*returnColumnSizes)[i] = 1;
109             i++;
110             printf("right: front:%d, back:%d
", front, back);
111         }
112         front++;
113         printf("

");
114     }
115     (*returnSize) = i;
116     // printf("returnSize :%d
", (*returnSize));
117     free(queue);
118     queue = NULL;
119     return result;
120     */
121 }

View Code

相关阅读:
log4j1修改DailyRollingFileAppender支持日志最大数量
 log4j1 修改FileAppender解决当天的文件没有日期后缀
 log4j生成有日期的日志文件名
 Java删除List和Set集合中元素
 Java并发编程：并发容器之ConcurrentHashMap
Java并发编程：并发容器之CopyOnWriteArrayList
java.util.ConcurrentModificationException解决详解
 Handshake failed due to invalid Upgrade header: null 解决方案
 web项目Log4j日志输出路径配置问题
 log4j.properties 的使用详解
原文地址：https://www.cnblogs.com/LydiammZuo/p/11886443.html