365天挑战LeetCode1000题——Day 072 重新排列数组将有序数组转换为二叉搜索树从前序与中序遍历序列构造二叉树二叉树的锯齿形层序遍历-优快云博客

本文链接：https://blog.youkuaiyun.com/ShowMeTheCod3/article/details/126577343

本文深入探讨了数组与二叉树相关的算法问题，包括重新排列数组、将有序数组转换为二叉搜索树、从前序与中序遍历序列构造二叉树以及二叉树的锯齿形层序遍历等问题的解决方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1470. 重新排列数组

在这里插入图片描述

代码实现（自解）

class Solution {
public:
    vector<int> shuffle(vector<int>& nums, int n) {
        int l = 0, r = n;
        vector<int> ans;
        while (n--) {
            ans.push_back(nums[l++]);
            ans.push_back(nums[r++]);
        }
        return ans;
    }
};

108. 将有序数组转换为二叉搜索树

在这里插入图片描述

代码实现（自解）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        if (!nums.size()) return nullptr;
        if (nums.size() == 1) return new TreeNode(nums[0]);
        int n = nums.size() / 2;
        vector<int> l(nums.begin(), nums.begin() + n);
        vector<int> r(nums.begin() + n + 1, nums.end());
        TreeNode* left = sortedArrayToBST(l);
        TreeNode* right = sortedArrayToBST(r);
        return new TreeNode(nums[n], left, right);        
    }
};

105. 从前序与中序遍历序列构造二叉树

在这里插入图片描述

代码实现（自解）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (!preorder.size()) return nullptr;
        if (preorder.size() == 1) return new TreeNode(preorder[0]);
        auto it = find(inorder.begin(), inorder.end(), preorder[0]);
        int left = it - inorder.begin();
        vector<int> leftPreorder(preorder.begin() + 1, preorder.begin() + 1 + left);
        vector<int> rightPreorder(preorder.begin() + 1 + left, preorder.end());
        vector<int> leftInorder(inorder.begin(), it);
        vector<int> rightInorder(it + 1, inorder.end());
        TreeNode* l = buildTree(leftPreorder, leftInorder);
        TreeNode* right = buildTree(rightPreorder, rightInorder);
        return new TreeNode(*it, l, right);
    }
};

103. 二叉树的锯齿形层序遍历

在这里插入图片描述

代码实现（自解）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        if (!root) return ans;
        bool goRight = true;
        deque<TreeNode*> myQueue;
        myQueue.push_back(root);
        while (!myQueue.empty()) {
            int sz = myQueue.size();
            vector<int> tmp;
            deque<TreeNode*> myTmpQueue;
            while (sz--) {
                if (goRight) {
                    TreeNode* tn = myQueue.front();
                    tmp.push_back(tn->val);
                    myQueue.pop_front();
                    if (tn->left) myTmpQueue.push_back(tn->left);
                    if (tn->right) myTmpQueue.push_back(tn->right);
                }
                else {
                    TreeNode* tn = myQueue.back();
                    tmp.push_back(tn->val);
                    myQueue.pop_back();
                    if (tn->right) myTmpQueue.push_front(tn->right);
                    if (tn->left) myTmpQueue.push_front(tn->left);
                }
            }
            goRight = !goRight;
            ans.push_back(tmp);
            myQueue = myTmpQueue;
        }
        return ans;
    }
};