力扣刷题记录-二叉树的前中后序遍历模板（统一模板，超级简单好记！！！）

已于 2023-06-11 20:25:36 修改
阅读量901 收藏
点赞数
分类专栏： 力扣刷题记录 文章标签： java 数据结构 算法
于 2022-04-09 17:11:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41857397/article/details/124061014
版权

这篇主要介绍二叉树遍历的递归方法和迭代方法。最后进行n叉树的遍历练习。

二叉树前中后序遍历分别对应力扣144、94、145题，n叉树遍历对应力扣589、590题。

目录

递归方法

//前序遍历
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new LinkedList<Integer>();//用res来存遍历结果
        preOrder(res,root);
        return res;
    }
    public void preOrder(List<Integer> res,TreeNode root){
        if(root==null)return;//递归终止条件，遍历到空节点就返回上一层
        res.add(root.val);//访问结点（这句位置决定递归顺序）
        preOrder(res,root.left);
        preOrder(res,root.right);
    }
}

//中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        inOrder(res,root);
        return res;
    }
    public void inOrder(List<Integer> res,TreeNode root){
        if(root==null)return;
        inOrder(res,root.left);
        res.add(root.val);
        inOrder(res,root.right); 
    }
}

//后序遍历
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res=new LinkedList<>();
        postOrder(res,root);
        return res;
    }
    public void postOrder(List<Integer> res,TreeNode root){
        if(root==null)return;
        postOrder(res,root.left);
        postOrder(res,root.right);
        res.add(root.val);
    }
}

迭代方法（未统一写法）

因为递归调用会把函数的局部变量、参数值和返回的地址入栈，return的时候从栈顶弹出上次的各项参数，所以递归可以返回上一层位置（实质是用栈记录下了上一层的信息）。所以三种遍历方式可以用栈来模拟递归的过程，也就是所谓的迭代（递归是一环套一环的执行，而迭代是按照一定的逻辑顺序向前推进）。

·前序迭代

前序遍历的顺序是根->左->右，需要先处理根结点（根节点先入栈，在后续每一次处理中，都将栈顶元素出栈，加入res中），然后将右孩子入栈，再将左孩子入栈，这样可以保证出栈的顺序是左孩子在右孩子前；

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res= new LinkedList<>();
        Stack<TreeNode> stack=new Stack<>();//栈里面存的是TreeNode类型的结点
        if(root!=null)stack.push(root);//如果空树，什么都不管，栈就是空的，最后直接返回空的res
        //前序遍历顺序（根左右），用栈模拟要根先入栈再出栈，然后右结点入栈，左节点入栈，这样出栈顺序就符合
        while(!stack.isEmpty()){
            root=stack.pop();
            res.add(root.val);
            if(root.right!=null)stack.push(root.right);
            if(root.left!=null)stack.push(root.left);
        }
        return res;
    }
}

·中序迭代

做完了前序迭代，肯定是想稍微改改前序迭代代码就套上中序，但这样是不行的。根源就在于对根结点的访问和处理上，前序的顺序是中左右，遍历过程中最先访问（遍历）的是根结点，每次循环中最先处理（出栈加入res）的也都是中间节点，然后是孩子结点。也就是说对结点访问和处理是连在一起的
但是中序遍历的顺序是左中右，要先访问根节点，然后一直向左子树访问，直到底部，开始处理结点（出栈加入res中），也就是说对结点的访问和处理是分开进行的，导致了处理和访问顺序的不一致。

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res =new LinkedList<>();
        if(root==null)return res;
        Stack<TreeNode> stack =new Stack<>();
        TreeNode cur=root;//用cur来遍历树
        //当栈或当前遍历结点非空的时候
        while(!stack.isEmpty()||cur!=null){
            if(cur!=null){//当前遍历结点非空，就要入栈，然后往左子树遍历
                stack.push(cur);
                cur=cur.left;//左
            }else{//当前遍历结点为空
                cur=stack.peek();//栈顶元素就是要处理的数据，用cur保存
                stack.pop();
                res.add(cur.val);//中
                cur=cur.right;//再往右子树遍历
            }
        }
        return res;
    }
}

·后序迭代

前序迭代顺序是中左右，后序是左右中，其实只要在前序基础上，将顺序变为中右左，再将最后的res翻转，就可以得到左右中的顺序；

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res =new LinkedList<>();
        if(root==null)return res;
        Stack<TreeNode> stack=new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            root=stack.pop();
            res.add(root.val);
            if(root.left!=null)stack.push(root.left);
            if(root.right!=null)stack.push(root.right);
        }
        Collections.reverse(res);
        return res;
    }
}

迭代方法（统一模板）

在前一组迭代写法中，中序遍历是因为需要先访问到最左下才可以开始处理结点，而前序是可以一边访问一边处理，这样导致了代码写法的不一致，为了统一这个风格，可以在遍历的过程中，都将结点入栈，只不过在要处理的节点（也就是要加入res的结点）入栈后再入栈一个null结点作为标记，这样在后续出栈中如果碰到null结点，就知道下一个出栈的结点是要加入res的，这样一来只要调整左中右结点的入栈顺序，就可以控制最后出栈的顺序；说得有些绕，直接看三种遍历的对比代码找感觉：

//前序遍历
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        Deque<TreeNode> stack=new LinkedList<>();
        if(root!=null)stack.push(root);
        while(!stack.isEmpty()){
            TreeNode cur=stack.peek();//cur获取栈顶元素
            if(cur!=null){//栈顶元素非空，出栈
                stack.pop();//避免后续对栈顶的元素重复操作，统一先出栈（前面已经用cur记录了，不怕丢）
                if(cur.right!=null)stack.push(cur.right);//若左右子树为空，则空节点不入栈，保证栈顶元素为空节点只发生在是中结点入栈后
                if(cur.left!=null)stack.push(cur.left);
                //因为是前序遍历（中左右），入栈要按右左中的顺序
                stack.push(cur);
                stack.push(null);//在中结点入栈后，null入栈作为标记；
            }else{//若栈顶元素为空，说明下一个栈顶元素是“中”结点
                stack.pop();//null出栈
                cur=stack.peek();//null的下一个栈顶元素就是“中结点”,用cur暂存
                stack.pop();//存下后就可出栈
                res.add(cur.val);
            }
        }
        return res;
    }
}

//中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res= new ArrayList<>();
        Deque<TreeNode> stack=new LinkedList<>();
        if(root!=null)stack.push(root);
        while(!stack.isEmpty()){
            TreeNode cur=stack.peek();
            if(cur!=null){
                stack.pop();
                if(cur.right!=null)stack.push(cur.right);
                stack.push(cur);
                stack.push(null);
                if(cur.left!=null)stack.push(cur.left);
            }
            else{
                stack.pop();
                cur=stack.peek();
                stack.pop();
                res.add(cur.val);
            }
        }
        return res;
    }
}

//后序遍历
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        Deque<TreeNode> stack= new LinkedList<>();
        if(root!=null)stack.push(root);
        while(!stack.isEmpty()){
            TreeNode cur=stack.peek();
            if(cur!=null){
                stack.pop();
                stack.push(cur);
                stack.push(null);
                if(cur.right!=null)stack.push(cur.right);
                if(cur.left!=null)stack.push(cur.left);
            }else{
                stack.pop();
                cur=stack.peek();
                stack.pop();
                res.add(cur.val);
            }
        }
        return res;

    }

可以观察到这样设置的话，代码的区别就只在于

//1
stack.push(cur);
stack.push(null);

以及

//2
if(cur.right!=null)stack.push(cur.right);
//3
if(cur.left!=null)stack.push(cur.left);

这三句的顺序的不同。

二叉树遍历

LeetCode 144. 二叉树的前序遍历

原题链接

2023.06.11 二刷

递归方法代码如下：

//递归版本
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        preOrder(res,root);
        return res;
    }
    public void preOrder(List<Integer> res,TreeNode root){
        if(root==null)return;
        res.add(root.val);
        preOrder(res,root.left);
        preOrder(res,root.right);
    }
}

迭代方法（非统一模板），代码如下：

//迭代版本
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res= new ArrayList<>();
        Deque<TreeNode> stack=new LinkedList<>();
        if(root!=null)stack.push(root);
        //前序遍历顺序（根左右），用栈模拟要根先入栈再出栈，然后右结点入栈，左节点入栈，这样出栈顺序就符合
        while(!stack.isEmpty()){
            root=stack.pop();
            res.add(root.val);
            if(root.right!=null)stack.push(root.right);
            if(root.left!=null)stack.push(root.left);
        }
        return res;
    }
}

迭代法，统一模板：

思想：

  迭代法需要使用栈，但用栈的话就无法解决遍历结点和处理结点的一致问题。
  那么将访问到的结点放入栈中，处理过的结点也放进去，但是要对它进行标记，即处理的结点放入栈中之后，紧接着放入一个空指针入栈作为标记。后面栈顶元素碰到null，说明null的下一个栈顶元素就是访问过但还没处理的元素，后面就可以对null进行出栈，保存下一个栈顶元素，然后栈顶元素出栈，将保存的元素值加入res

代码如下：

//迭代统一版
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        if(root==null)return res;
        Deque<TreeNode> stack=new LinkedList<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode cur=stack.pop();//栈顶出栈，并让cur存储出栈元素
            if(cur!=null){//出栈栈顶元素的非
                // 判断出栈元素左右子树是否为空，不为空就入栈
                if(cur.right!=null)stack.push(cur.right);
                if(cur.left!=null)stack.push(cur.left);
                //因为是前序遍历（中左右），入栈要按右左中的顺序
                stack.push(cur);
                stack.push(null);//在中结点入栈后，null入栈作为标记；
            }else{//若栈顶元素为空，说明下一个栈顶元素是“中”结点
                cur=stack.pop();;//null的下一个栈顶元素就是“中结点”,用cur暂存
                res.add(cur.val);
            }
        }
        return res;
    }
}

LeetCode 145. 二叉树的后序遍历

原题链接

2023.06.11 二刷

递归版本代码如下：

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res=new LinkedList<>();
        postOrder(res,root);
        return res;
    }
    public void postOrder(List<Integer> res,TreeNode root){
        if(root==null)return;
        postOrder(res,root.left);
        postOrder(res,root.right);
        res.add(root.val);
    }
}

迭代版本，修改自前序遍历
前序遍历：中左右，调整代码入栈顺序->中右左，反转res->左右中（后续遍历）

代码如下：

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res =new Arraylist<>();
        if(root==null)return res;
        Deque<TreeNode> stack=new LinkedList<>();
        stack.push(root);
        while(!stack.isEmpty()){
            root=stack.pop();
            res.add(root.val);
            if(root.left!=null)stack.push(root.left);
            if(root.right!=null)stack.push(root.right);
        }
        Collections.reverse(res);
        return res;
    }
}

迭代法，统一模板，代码如下：

//统一版本
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        if(root==null)return res;
        Deque<TreeNode> stack= new LinkedList<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode cur=stack.pop();
            if(cur!=null){
                stack.push(cur);
                stack.push(null);
                if(cur.right!=null)stack.push(cur.right);
                if(cur.left!=null)stack.push(cur.left);
            }else{
                cur=stack.pop();
                res.add(cur.val);
            }
        }
        return res;

    }
}

LeetCode 94. 二叉树的中序遍历

原题链接

2023.06.11 二刷

递归版本，代码如下：

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        inOrder(res,root);
        return res;
    }
    public void inOrder(List<Integer> res,TreeNode root){
        if(root==null)return;
        inOrder(res,root.left);
        res.add(root.val);
        inOrder(res,root.right);
        
    }
}

迭代法，非统一模板

中序遍历与前序和后序遍历不太一样
前序遍历的时候，遍历结点和处理结点是一起前后进行的，而中序遍历无法这样

代码如下：


class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res =new LinkedList<>();
        if(root==null)return res;
        Stack<TreeNode> stack =new Stack<>();
        TreeNode cur=root;//用cur来遍历树
        //当栈或当前遍历结点非空的时候
        while(!stack.isEmpty()||cur!=null){
            if(cur!=null){//当前遍历结点非空，就要入栈，然后往左子树遍历
                stack.push(cur);
                cur=cur.left;//左
            }else{//当前遍历结点为空
                cur=stack.peek();//栈顶元素就是要处理的数据，用cur保存
                stack.pop();
                res.add(cur.val);//中
                cur=cur.right;//再往右子树遍历
            }
        }
        return res;
    }
}

迭代法，统一模板，代码如下：

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res= new ArrayList<>();
        if(root==null)return res;
        Deque<TreeNode> stack=new LinkedList<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode cur=stack.pop();
            if(cur!=null){ 
                if(cur.right!=null)stack.push(cur.right);
                stack.push(cur);
                stack.push(null);
                if(cur.left!=null)stack.push(cur.left);
            }else{
                cur=stack.pop();
                res.add(cur.val);
            }
        }
        return res;
    }
}

n叉树的遍历

LeetCode 589. N 叉树的前序遍历

原题链接

//递归法
class Solution {
    List<Integer> res=new ArrayList<>();
    public List<Integer> preorder(Node root) {
        if(root==null)return res;
        res.add(root.val);
        for(Node child:root.children)preorder(child);
        return res;
    }
}

/*
前序遍历顺序是根-左-右，每层循环里面都是根结点先出栈，加入res，可以保证结果集中根会在孩子结点前；
还需要解决左右的顺序，栈先进后出的特性，要先让右孩子入栈，这样后面出栈可让左孩子先出栈加入res，保证结果集中的左-右顺序；结合起来就是根-左-右的顺序；
*/
//借助栈实现的迭代法
class Solution {
    public List<Integer> preorder(Node root) {
        List<Integer> res=new ArrayList<>();
        if(root==null)return res;
        Stack<Node>stack=new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            root=stack.pop();
            res.add(root.val);
            //因为栈先进后出，所以需要先让右边的孩子结点入栈
            for(int i=root.children.size()-1;i>=0;--i)stack.push(root.children.get(i));
        }
        return res;
    }
}

LeetCode 590. N 叉树的后序遍历

原题链接

//递归法
class Solution {
    List<Integer> res=new ArrayList<>();
    public List<Integer> postorder(Node root) {
        if(root==null)return res;
        for(Node child:root.children)postorder(child);
        res.add(root.val);
        return res;
    }
}

/*
与前序遍历迭代改后序遍历迭代类似，前序是根-左-右，后序是左-右-根；
只要在入栈时，让左孩子先于右孩子入栈，这样出栈就是右孩子先出，保证右-左顺序加入res；
而根总是先于孩子结点入栈，在孩子结点入栈的那层循环里，根结点值已经加入res；
这样可以保证结果集里是根-右-左，只要最后翻转res就可以变成左-右-根；
*/
//后序迭代法
class Solution {
    public List<Integer> postorder(Node root) {
        List<Integer> res=new ArrayList<>();
        if(root==null)return res;
        Stack<Node>stack=new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            root=stack.pop();
      			 res.add(root.val);
            for(int i=0;i<root.children.size();++i)
                stack.push(root.children.get(i));
        }
        Collections.reverse(res);
        return res;
    }
}
纪宁app
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法设计之二叉树的遍历
lishinho的博客
03-18 803
最近发现面试很喜欢考二叉树的遍历，所以补一个。 树的节点结构： public class TreeNode{ public int value; public TreeNode left; public TreeNode right; public TreeNode(int data){ this.data = data; } } 一...
LeetCode中二叉树遍历问题
听雪楼
12-11 496
前置知识 二叉树遍历的相关知识, 可以参考我的另外一篇二分搜索树的博文,地址如下: https://blog.csdn.net/love905661433/article/details/82981527 前序遍历 LeetCode-144. 二叉树的前序遍历 题目 给定一个二叉树，返回它的 前序 遍历。 示例: 输入: [1,null,2,3] 1 \ 2 /...
[Leedcode][JAVA][第94/144/145题][前中后序遍历][递归][迭代][二叉树]
dadongwudi的博客
05-14 168
【问题描述】[] 前序遍历 先输出当前结点的数据，再依次遍历输出左结点和右结点 中序遍历 先遍历输出左结点，再输出当前结点的数据，再遍历输出右结点 后续遍历 先遍历输出左结点，再遍历输出右结点，最后输出当前结点的数据 【解答思路】 递归 /迭代（栈） 时间复杂度：O(N) 空间复杂度：O(N) 1. 前序遍历 1.1 递归 二叉树遍历（前序、中序、后序）的递归方法，唯一改变的是记录节点值操作的位置 class Solution { public List<Integer
二叉树的中序遍历_LeetCode刷题实战105：从前序与中序遍历序列构造二叉树
weixin_39881958的博客
12-04 171
算法的重要性，我就不多说了吧，想去大厂，就必须要经过基础知识和业务逻辑面试+算法面试。所以，为了提高大家的算法能力，这个公众号后续每天带大家做一道算法题，题目就从LeetCode上面选 ！今天和大家聊的问题叫做从前序与中序遍历序列构造二叉树，我们先来看题面：https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/Giv...
leetcode_二叉树遍历总结_Java版
qazwsxxxxxasd的博客
12-30 523
假期了继续刷刷leetcode吧！ 前序，中序，后序递归实现 class Solution { public List<Integer> preorderTraversal(TreeNode root) { List<Integer> ans = new ArrayList<Integer>(); preorder(root,ans); return ans; } public void preor
力扣刷题-python-二叉树-1（三种遍历方法 递归、 迭代 、全模板）
luxppp880的博客
12-19 1489
1.二叉树 二叉树分为满二叉树和完全二叉树 1）满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。 度为0说明孩子节点为0，度为2说明孩子节点为2 、 这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。 2）完全二叉树 完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^h -1 个节点。 3)
力扣刷题记录-二叉树的结构相关题目
qq_41857397的博客
04-29 521
对力扣中有关二叉树结构的一些题目进行汇总记录，包括每一题的多种解法。
力扣刷题记录--二叉树/二叉搜索树相关问题
qq_41857397的博客
06-12 991
摘录LeetCode中与二叉树相关的题目，以及一些常用的解法模板
力扣刷题记录-翻转二叉树的各种方法
qq_41857397的博客
04-14 147
用力扣翻转二叉树一题回顾二叉树的各种遍历方式
leetcode530-leetcode-note:力扣刷题笔记
06-30
N叉树的后序遍历 N叉树的前序遍历 山峰数组的峰顶索引 Nim游戏 二叉树的前序遍历 数字的补数 按奇偶排序数组 翻转字符串 N叉树的最大深度 将有序数组转换为二叉搜索树 单值二叉树 Excel表格序列号 独特的电子邮件...
代码随想录-力扣刷题-总结笔记01
upward
02-27 1046
代码随想录-力扣刷题-总结笔记01
代码随想录-力扣刷题-总结笔记02
upward
04-04 938
代码随想录-力扣刷题-总结笔记02
力扣树专题-6 广度优先搜索 刷熟一个模板（层序遍历打印二叉树）秒杀一堆问题leetcode102 111 116 617 java刷题笔记
一碗菜粥的博客
06-13 2507
广度优先搜索算法BFS专题 根据一个模板 秒杀其他题目
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1193
浅析synchronized锁升级的原理与实现
在Java Web开发中，如何保障应用的安全性？请列举常见的安全策略和措施。请解释Spring框架中的事务管理，包括声明式事务和编程式事务。
最新发布
weixin_53180424的博客
09-03 677
在实际开发中，声明式事务管理因其非侵入性和易维护性而更受欢迎。它允许开发者将注意力集中在业务逻辑上，而不是事务管理的细节上。然而，在某些特殊场景下，编程式事务管理可能提供更灵活的控制力。因此，在选择事务管理方式时，应根据实际需求和场景来决定。
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 669
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
操作系统原子操作
zzt_is_me的博客
08-28 8681
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
MapStruct-Java实体转换利器
m0_63622279的博客
09-02 404
MapStruct 是一个用于生成映射器接口的代码生成库，主要用于简化 Java 对象之间的转换过程。在处理不同模型之间数据转换时，MapStruct 可以自动生成实现类减少手工转换逻辑的工作量。使用场景：各种模型之间的转换。BODTOVOPOJO引入mapstruct的pom依赖定义mapper接口（注意，这里不是MyBatis的Mapper哦），使用@Mapper注解标记，并在接口中声明映射方法。编写映射方法，（从xxxO转换为yyyO,模型之间的转换）在业务层中使用Mapper。
力扣刷题--LCR 135. 报数python
07-23
"LCR 135. 报数" 是力扣（LeetCode）上的一个问题编号，它是一个经典的Python编程题目，涉及到数组操作和游戏策略。在这个“报数”游戏中，给定一个非空整数数组 `nums` 和两个整数 `m` 和 `n`，玩家轮流从数组中选择一个元素并将其乘以 `m` 或者除以 `n`（除数必须是正整数），直到数组所有元素变为相同的值。如果数组中的最后一个元素不是 1，那么游戏结束，当前玩家失败。 以下是你可以参考的基本思路： 1. 初始化变量 `target` 为数组的最大元素，这将是游戏的目标值。 2. 遍历数组计算目标值 `target`，同时更新每个元素的最小倍数，即 `minTimes[i] = log(target / nums[i])`，表示让 nums[i] 变为 target 所需的最小步数。 3. 创建一个布尔数组 `visited` 来标记哪些元素已经被选过。 4. 使用递归模拟游戏过程：对于每个未访问过的元素，检查当前玩家能否通过操作使其满足目标条件；然后递归地尝试对手的操作。 5. 返回最后一位玩家是否可以达到获胜状态，也就是目标值为 1。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值