DAY17|二叉树part2

已于 2024-05-05 15:14:28 修改
阅读量776 收藏 15
点赞数 25
分类专栏： 代码随想录训练营打卡记录 文章标签： 算法 leetcode 数据结构 c++
于 2024-05-05 15:09:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47963219/article/details/138449237
版权

目录

层序遍历

一个打十个！

102 二叉树的层序遍历

/**
 * 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>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        if(root==nullptr) return result;
        queue<TreeNode*> q;
        q.push(root);
        while(q.empty()==0){
            int size=q.size();
            vector<int> each;
            while(size--){
                TreeNode* t=q.front();
                each.push_back(t->val);
                q.pop();
                if(t->left!=nullptr) q.push(t->left);
                if(t->right!=nullptr) q.push(t->right);
            }
            result.push_back(each);
        }
        return result;
    }
};

107. 二叉树的层序遍历II

具体思路就是在上一题的基础上把result的数组利用双指针翻转过来。

/**
 * 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>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
        if(root==nullptr) return result;
        queue<TreeNode*> q;
        q.push(root);
        while(q.empty()==0){
            int size=q.size();
            vector<int> each;
            while(size--){
                TreeNode* t=q.front();
                each.push_back(t->val);
                q.pop();
                if(t->left!=nullptr) q.push(t->left);
                if(t->right!=nullptr) q.push(t->right);
            }
            result.push_back(each);
        }
        int n=result.size();//数组个数
        int left=0,right=n-1;
        while(left<right){
            vector<int> p=result[left];
            result[left]=result[right];
            result[right]=p;
            ++left;
            --right;
        }
        return result;
    }
    
};

199 二叉树的右视图

也是层序遍历，返回遍历后的每一层的最后一个元素

/**
 * 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<int> rightSideView(TreeNode* root) {
        vector<int> result;
        if (root == nullptr)
            return result;

        queue<TreeNode*> q;
        q.push(root);
        while (q.empty() != 1) {
            int size=q.size();
            int rightest;
            while(size--){
                TreeNode* t=q.front();
                rightest=t->val;
                q.pop();
                if(t->left != nullptr) q.push(t->left);
                if(t->right != nullptr) q.push(t->right);
            }
            result.push_back(rightest);
        }
        return result;
    }
};

其实我这里没写判断目前元素是否为该层最后一个元素的语句。我只是在每层内进行遍历的时候，每次都将当前元素的val存入rightest变量，不停覆盖，直到最后一个元素结束后跳出当前层的循环，此时rightest没有被覆盖，就直接是当前层的最后一个元素，此时直接存入result数组即可。

637.二叉树的层平均值

注意两个点：第一个是在计算每层之和的时候需要使用Long int不然会溢出。
第二个是在最后求均值的时候，定义了一个double型变量，但是不能直接把sum/n赋值给此变量，不然得到的还是Int型数，应该先把总和赋给double型变量，然后用这个double来除以n求平均值，得到的才能是double。

/**
 * 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<double> averageOfLevels(TreeNode* root) {
        vector<double> result;
        if(root==nullptr) return result;
        queue <TreeNode*> q;
        q.push(root);
        while(q.empty()==0){
            int size=q.size();
            int n=size;
            long int sum=0;
            while(size--){
                TreeNode* t=q.front();
                sum+= t->val;
                q.pop();
                if(t->left!=nullptr) q.push(t->left);
                if(t->right!=nullptr) q.push(t->right);
            }
            double each =sum;
            each=each/n;
            result.push_back(each);
        }
        return result;
    }
};

429. N 叉树的层序遍历

和二叉树层序遍历也没有啥不同

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> result;
        if(root==nullptr) return result;
        queue<Node*> q;
        q.push(root);
        while(q.empty()==0){
            int size=q.size();
            vector<int> each;
            while(size--){
                Node* t=q.front();
                each.push_back(t->val);
                q.pop();
                vector<Node*> ch=t->children;
                int n=ch.size();
                for(int i=0;i<n;++i){
                    q.push(ch[i]);
                }
            }
            result.push_back(each);
        }
        return result;
    }
};

515. 在每个树行中找最大值

用模板写。。真的又快又简单。。。

/**
 * 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<int> largestValues(TreeNode* root) {
        vector<int> result;
        if(root==nullptr) return result;
        queue <TreeNode*> myQue;
        myQue.push(root);
        while(myQue.empty()==0){
            int size=myQue.size();
            int M=INT_MIN;
            while(size--){
                TreeNode* t=myQue.front();
                M=max(M,t->val);
                myQue.pop();
                if(t->left) myQue.push(t->left);
                if(t->right) myQue.push(t->right);
            }
            result.push_back(M);
        }
        return result;
    }
};

116. 填充每个节点的下一个右侧节点指针

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        if(root==NULL) return root;
        queue<Node*> myque;
        myque.push(root);
        while(myque.empty()==0){
            int size=myque.size();
            Node* prev;
            Node* curr;
            for(int i=0;i<size;++i){
                
                if(i==0){
                    prev=myque.front();
                    myque.pop();
                    if(prev->left) myque.push(prev->left);
                    if(prev->right) myque.push(prev->right);
                }
                else{
                    curr=myque.front();
                    myque.pop();
                    if(curr->left) myque.push(curr->left);
                    if(curr->right) myque.push(curr->right);
                    prev->next=curr;
                    prev=curr;
                }
            }
            prev->next=NULL;
        }
        return root;
    }
};

相比正常的层序遍历方法有一点点绕，因为要考虑是否为本层第一个节点。之前在每层遍历的时候我喜欢直接用while(size–)，这里用for循环会更容易判断是否为本层第一个节点。

117. 填充每个节点的下一个右侧节点指针 II

和上一道题一模一样的代码。。。完全没区别直接复制粘贴也能AC。
略了。

104.二叉树的最大深度

简简单单层序遍历，计个层数就行。

/**
 * 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:
    int maxDepth(TreeNode* root) {
        int result=0;
        if(root==nullptr) return result;
        queue<TreeNode*> myque;
        myque.push(root);
        while(myque.empty()==0){
            int size=myque.size();
            result++;
            while(size--){
                TreeNode* t=myque.front();
                myque.pop();
                if(t->left) 
                    myque.push(t->left);
                if(t->right) 
                    myque.push(t->right);
            }
        }
        return result;
    }
};

111. 二叉树的最小深度

/**
 * 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:
    int minDepth(TreeNode* root) {
        int result=0;
        if(root==nullptr) return result;
        queue<TreeNode*> myque;
        myque.push(root);
        while(myque.empty()==0){
            int size=myque.size();
            result++;
            while(size--){
                TreeNode* t=myque.front();
                if(t->left==nullptr && t->right==nullptr) return result;
                myque.pop();
                if(t->left) myque.push(t->left);
                if(t->right) myque.push(t->right);
            }
        }
        return result;
    }
};

有点点绕，本质还是层序遍历，在遍历每层的时候找本层是否存在叶节点，若存在则直接返回当前层数。

层序遍历的十道题刷完了，会了模板以后真的又简单又快，库库就是一顿写啊。

226. 翻转二叉树

也许可以层序遍历每个节点，然后交换每个节点的左右子节点？
让我来试一下：

/**
 * 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* invertTree(TreeNode* root) {
        if(root==nullptr) return root;
        queue<TreeNode*> myque;
        myque.push(root);
        while(myque.empty()==0){
            int size=myque.size();
            while(size--){
                TreeNode* t=myque.front();
                myque.pop();
                TreeNode* help=t->left;
                t->left=t->right;
                t->right=help;
                if(t->left) myque.push(t->left);
                if(t->right) myque.push(t->right);
            }
        }
        return root;
    }
};

可以AC。
看了题解：
这道题使用前序后序遍历也可以，（中序遍历不可以因为会把某些节点翻转两次），层序遍历也可以实现

二叉树解题的大忌就是自己稀里糊涂的过了（因为这道题相对简单），但是也不知道自己是怎么遍历的。

再试试深度优先遍历的非递归和递归方法来实现这道题：
递归方法的前序遍历：

/**
 * 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* invertTree(TreeNode* root) {
        process(root);
        return root;
    }
    void process(TreeNode* root){
        if(root==nullptr) return;
        TreeNode* t=root->left;
        root->left=root->right;
        root->right=t;
        process(root->left);
        process(root->right);
    }
};

非递归方法的前序遍历：

/**
 * 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* invertTree(TreeNode* root) {
        if(root==nullptr) return root;
        stack<TreeNode*> myst;
        myst.push(root);
        while(myst.empty()==0){
            TreeNode* t=myst.top();
            myst.pop();
            TreeNode* a=t->left;
            t->left=t->right;
            t->right=a;
            if(t->right) myst.push(t->right);
            if(t->left) myst.push(t->left);
        }
        return root;
    }
};

odk, 下一题

101 对称二叉树

没什么思路。。
看题解：
其实本质是看头节点下面左右节点的二叉树是否为对方的翻转版本。
写一个递归分别遍历两个二叉树，遍历的时候比较左树外侧和右树外侧，左树内侧和右树内侧的节点是否相等即可

/**
 * 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:
    bool isSymmetric(TreeNode* root) {
        bool result=true;
        if(root==nullptr) return result;
        process(root->right,root->left,result);
        return result;
    }
    void process(TreeNode* right, TreeNode* left, bool& result){
        if(left==nullptr && right==nullptr) return;
        if(left==nullptr && right!=nullptr) {
            result=false;
            return;
        }
        if(right==nullptr&& left!=nullptr){
            result=false;
            return;
        }
        if(right->val != left->val){
            result=false;
            return;
        }
        process(right->right,left->left,result);

        process(left->right,right->left,result);
    }
};

非递归版本：

/**
 * 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:
    bool isSymmetric(TreeNode* root) {
        //bool result;
        if(root==nullptr) return true;
        if(root->left==nullptr && root->right!=nullptr) return false;
        if(root->right==nullptr && root->left != nullptr) return false;
        if(root->left==nullptr&& root->right==nullptr) return true;
        queue<TreeNode*> myque;
        myque.push(root->left);
        myque.push(root->right);
        while(myque.empty()==0){
            int size=myque.size();
            if(size%2) return false;
            for(int i=0;i<size;++i){
                TreeNode* a=myque.front();
                myque.pop();
                TreeNode* b=myque.front();
                myque.pop();
                ++i;
                if(a==nullptr&&b!=nullptr) return false;
                if(a!=nullptr&&b==nullptr) return false;
                if(a==nullptr&&b==nullptr) continue;
                if(a->val !=b->val) return false;
                myque.push(a->left);
                myque.push(b->right);
                myque.push(a->right);
                myque.push(b->left);
            }
        }
        return true;
    }
};

用队列，把左右子树对应的节点依次存入队列，一次弹出两个进行比对，而且是按层比对，但跟层序遍历入队列的顺序不太相同。

DAY17的内容完事，看了一下对二叉树的周末小结：
“
在实现迭代法的过程中，有同学问了：递归与迭代究竟谁优谁劣呢？

从时间复杂度上其实迭代法和递归法差不多（在不考虑函数调用开销和函数调用产生的堆栈开销），但是空间复杂度上，递归开销会大一些，因为递归需要系统堆栈存参数返回值等等。

递归更容易让程序员理解，但收敛不好，容易栈溢出。
这么说吧，递归是方便了程序员，难为了机器（各种保存参数，各种进栈出栈）。
在实际项目开发的过程中我们是要尽量避免递归！因为项目代码参数、调用关系都比较复杂，不容易控制递归深度，甚至会栈溢出。

”
over!

kirinenko
关注
  • 25
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
代码随想录算法训练营Day17|| 二叉树part05
DetouringSnail的博客
06-23 86
98.验证二叉搜索树：初看觉得简单，自己写的依托。陷阱在于要保证右子树所有节点的值都要大于根节点，而不是单纯右孩子。暴力解法是用中序遍历一遍二叉树，判断数组是否递增。优化后的解法其实就是变换后的双指针，每遍历一个二叉树节点，判断他的值要大于前一个节点的值。654.最大二叉树：和昨天后序中序构造二叉树异曲同工，今天尝试了用操作索引来简化代码的写法，第一次果然写出很多问题。617.合并二叉树：久违的简单题，处理两棵树的终止条件，可以顺便复习对称二叉树那题。注意涉及到二叉搜索树，要想到中序遍历。
DAY20|二叉树part4
weixin_47963219的博客
05-10 772
思路：可以两棵树同时遍历，比较节点。可以递归可以迭代。* };if(p!return;if(p->val!迭代，对层序遍历比较熟练，写一下：/*** int val;* };pst.pop();qst.pop();* };*/
DAY22|二叉树part6
weixin_47963219的博客
05-20 464
递归思路： 参数应该是输入数组，返回值是一个节点 遍历找到数组最大值的下标，然后new一个根节点出来，左右子是递归送进去的该数组的左右下标。 终止条件就是传入数组为0 AC感觉可以两个都层序遍历，然后null也算节点. 但这样无法根据队列是否为空来判断遍历是否结束。需要设置一个其他的标志位。 这样试了一下发现不行，层序遍历无法按层来新构建一个二叉树或者在原始二叉树上直接覆盖。因为创建节点（除非是根节点）需要跟他的父节点相连，但层序遍历只在本层循环，无法得到上一层的信息。换递归。 递归的话感觉需要前序遍历才能
DAY23|二叉树part07
weixin_47963219的博客
05-20 323
markdown出问题了打不出字来，，这版没写完
DAY21|二叉树PART5
weixin_47963219的博客
05-11 281
感觉也不是不能做，可以存一下每层弹出的第一个元素（也就是最左边的元素），然后最后退出循环的时候这个空间里存的就是最底层最左边的元素，返回这个节点的值就可以了。因为（最差的情况的话）要遍历所有头节点到叶节点的路径找是否有相似的和，相当于每找到一条路径之和就比对一下。如果按左中右顺序递归，需要返回当前节点的深度，最后取一个深度最大最左面的节点作为结果。根据中序遍历的左子树的长度可以在后序遍历中从头开始得到左子树（后序遍历版）的长度。要不然就是先遍历求总的层数（深度），然后再次遍历到最后一层取最左边的元素。
Leetcoder Day16｜ 二叉树 part05
dawnstudy
02-19 1009
（2）
代码随想录打卡Day17| 二叉树part04
lionelwhl的博客
07-17 108
第二题、二叉树的所有路径 LeetCode257。第一题、平衡二叉树 LeetCode 110。
Leetcoder Day13｜ 二叉树 part02
dawnstudy
01-18 1084
因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。参数就是要传入节点的指针，题目中给出的要返回root节点的指针，可以直接使用题目定义好的函数，所以就函数的返回类型为。二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了。此时进入单层递归的逻辑，单层递归的逻辑就是处理 左右节点都不为空，且数值相同的情况。按照中左右的顺序，先进行交换左右孩子节点，然后反转左子树，反转右子树。
Leetcoder Day17｜ 二叉树 part06
dawnstudy
02-22 1026
这道题我的第一个想法是建立一个哈希表，层次遍历并存储第一个树的位置和值，如果该位置没有节点则为-1，随后创建新的节点，遍历第二个树，若当前位置已经有节点，则将两个节点值相加返回；注意在Java中，如果将树转换为列表List，则需要用.get和size()来获取列表的值和长度，如果是数组，因为不知道树的节点个数，所以需要先设置一个很大的值，所以也可以先将树转换为列表，再将列表转换为数组。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。
力扣刷题 | 二叉树
12-20
文章目录总述基本概念二叉树性质二叉树遍历94 二叉树的中序遍历95 不同的二叉搜索树296 不同的二叉搜索树98 验证二叉搜索树100 相同的树101 对称二叉树102 二叉树的层序遍历103 二叉树的锯齿形层次遍历104 二叉树的...
cyxpdc#Algorithm#(简单|二叉树|*)左叶子之和1
07-25
示例：在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24对每个节点，都得到它的左叶子，而右叶子将会被置为0，这样就得到了所有左叶子* Defin
二叉树_17281183_刘梦婷_splitns2_扩展先序序列_二叉树_
10-03
按先序遍历的扩展序列建立二叉树的二叉链表存储结构，实现二叉树先序、中序、后序遍历的递归算法，实现二叉树中序遍历的非递归算法，实现二叉树层次遍历的非递归算法，求二叉树的结点个数，求二叉树的深度。
代码随想录 Day14 二叉树
02-07
二叉树的原理以及实现代码
二叉树2.dsw
11-30
二叉树的基本功能实现，你二叉树的基本功能实现，你二叉树的基本功能实现，你二叉树的基本功能实现，你二叉树的基本功能实现，你二叉树的基本功能实现，你二叉树的基本功能实现，你二叉树的基本功能实现，你二叉树的...
leetcode 403周赛 包含所有1的最小矩形面积||「暴力」
Suryxin's blogs
07-01 581
leetcode 403周赛 包含所有1的最小矩形面积||「暴力」
69. x 的平方根（简单）
最新发布
用魔法打败魔法，走楼梯啊！
07-01 746
对于此题，是计算算术平方根的整数部分，因此等价于寻找首次平方之和大于x的数，该数减1即为x的算术平方根（假定x的算术平方根为y.z,其中y为整数部分，z为小数部分，y*y的结果是小于x，而(y+1）*(y+1)是大于x的）。不能使用系统内置的函数，寻找某个数（假定为x）的算术平方根，并返回算术平方根的整数部分，最直观的方法是从0依次开始尝试所有小于等于x的数（假定为y），当y*y的积小于等于x时，继续遍历下一个数，直至y*y的积首次大于x时，此时y-1即为x的算术平方根的整数部分，如。
【算法——快慢指针&链表】
2301_76758064的博客
06-30 153
2—针对19这道力扣例题：会有一些变故：就是长度为1的情况；这时next->next就会报错，所以要设置一个新的链表，即在题目给我们的前面加一个节点（new）1—p2指针先走k步，然后p1和p2都1/s；直到p2走完时（p2->next==NULL），p1->next即为所删。快指针2/s，慢指针1/s；快指针前进要求：当前的下一个都是非空；快指针不满足时，慢指针所指就是中点。快慢指针一开始都在开头，快指针2/s，慢指针1/s；3—这道题很多解法，看力扣历史题解（画个图就通透了）
day54--面试专题（基础篇）
ZHUSHANGLIN的博客
06-28 1061
有一个有序表为 1,5,8,11,19,22,31,35,40,45,48,49,50 当二分查找值为 48 的结点时，查找成功需要比较的次数。使用二分法在序列 1,4,6,7,15,33,39,50,64,78,75,81,89,96 中查找元素 81 时，需要经过（ ）次比较。② A[M] > T，中间值右侧的其它元素都大于 T，无需比较，中间索引左边去找，M - 1 设置为右边界，重新查找。将数组分为两个子集，排序的和未排序的，每一轮从未排序的子集中选出最小的元素，放入排序子集。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值