LeetCode第102题----二叉树的层序遍历

万题皆源二叉树，所以今天继续分享二叉树的相关题目

---

前言

对于二叉树来说，我们常见的操作有前序、中序、后序、层序遍历，这篇文章分享层序遍历，也是LeetCode第102题。

---

本人才疏学浅，若有错误，请联系本人进行更改。

一、层序遍历

层序遍历是指逐层的，先左后右的遍历一颗树。

遍历顺序：

二、数据结构

我们可以使用两个队列来操作数的节点和节点的孩子，用一个数组来保存结果，最后输出结果即可。

三、代码实现

Python代码：

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        #跟结点入queue
        queue = [root]
        res = []
        while queue:
            res.append([node.val for node in queue])
            #存储当前层的孩子节点列表
            ll = []
            #对当前层的每个节点遍历
            for node in queue:
                #如果左子节点存在，入队列
                if node.left:
                    ll.append(node.left)
                #如果右子节点存在，入队列
                if node.right:
                    ll.append(node.right)
            #后把queue更新成下一层的结点，继续遍历下一层
            queue = ll
        return res

C++代码：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector <vector <int>> ret;
        if (!root) {
            return ret;
        }

        queue <TreeNode*> q;
        q.push(root);
        while (!q.empty()) {
            int currentLevelSize = q.size();
            ret.push_back(vector <int> ());
            for (int i = 1; i <= currentLevelSize; ++i) {
                auto node = q.front(); q.pop();
                ret.back().push_back(node->val);
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
        }
        
        return ret;
    }
};

C语言代码：代码取自

int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    int **ans = (int **)malloc(sizeof(int *) * 1000);
    *returnColumnSizes = (int *)malloc(sizeof(int) * 1000);
    *returnSize = 0;
    if (!root)
        return ans;

    int l = 0, r = 0;
    struct TreeNode *q[2000];
    q[r++] = root;
    while (l < r) {
        int cnt = 0;
        int tmp = r;
        ans[*returnSize] = (int *)malloc(sizeof(int) * 1000);
        while (l < tmp) {
            if (q[l]->left)
                q[r++] = q[l]->left;
            if (q[l]->right)
                q[r++] = q[l]->right;
            ans[*returnSize][cnt++] = q[l]->val;
            l++;
        }
        (*returnColumnSizes)[(*returnSize)++] = cnt;
    }
    return ans;
}

Java代码：代码取自

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ret = new ArrayList<List<Integer>>();
        if (root == null) {
            return ret;
        }

        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            List<Integer> level = new ArrayList<Integer>();
            int currentLevelSize = queue.size();
            for (int i = 1; i <= currentLevelSize; ++i) {
                TreeNode node = queue.poll();
                level.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            ret.add(level);
        }
        
        return ret;
    }
}

总结

今天的分享到此为止，感谢我家莫莫的陪伴与等候。