为啥我的代码一直在第二个循环内不会跳出


public static void main(String[] args) {
        int count = 0;
        for (int i = 100; i <= 999; i++) {
            double result = 0;
            for (int j = 0; j < 3; j++) {
                result = result + Math.pow(i % 10, 3);
                i = i / 10;
            }
            if (result == i) {
                count++;
            }
        }
        System.out.println("水仙花数有 : " + count + "个");
    }

因为你内循环改变了 i，而外循环是根据 i 进行循环的，
所以你要把内循环的 i 改成一个临时变量 t，修改如下：

public static void main(String[] args){
        int count = 0;
        for (int i = 100; i <= 999; i++) {
            double result = 0;
            int t = i;
            for (int j = 0; j < 3; j++) {
                result = result + Math.pow(t % 10, 3);
                t = t / 10;
            }
            if (result == i) {
                count++;
            }
        }
        System.out.println("水仙花数有 : " + count + "个");
    }

你每次i都变成0了，怎么会退出呢，这就是个死循环，你还没有主动break，最终就是StackOverflowError

该回答引用GPT:
在代码中，第二个循环内变量'i'的值被改变了，导致第二个循环没有正常结束。具体来说，第二个循环内i的值被改成了1，但其值范围并没有在第二个循环的上界限制内。因此，程序一直在第二个循环内执行，导致程序无法跳出。为了解决这个问题，可以在第二个循环内声明另一个变量j，初始值为i，并在第二层循环内对j进行操作。具体代码如下：

public static void main(String[] args) {
    int count = 0;
    for (int i = 100; i <= 999; i++) {
        int j = i;
        double result = 0;
        for (int k = 0; k < 3; k++) {
            result = result + Math.pow(j % 10, 3);
            j = j / 10;
        }
        if (result == i) {
            count++;
        }
    }
    System.out.println("水仙花数有 : " + count + "个");
}

这里，在第二个循环内我们声明了一个新的变量j，初始值为i，这样就可以在第二个循环内使用j而不改变i的值，保证了i的值可以在第一个循环内正常遍历。同时，也更好地符合变量的单一职责原则，提高了代码可读性和可维护性。
如还有疑问，可留言帮助解决。

i = i / 10;
i不会达到循环退出条件。

帮你找了个相似的问题, 你可以看下: https://ask.csdn.net/questions/7482921
我还给你找了一篇非常好的博客，你可以看看是否有帮助，链接：将一个有序数组转换成二叉排序树
除此之外, 这篇博客: ＜力扣刷题＞1305. 两棵二叉搜索树中的所有元素中的 二、方法 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:

二叉搜索树的定义：
二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树） 它或者是一棵空树，或者是具有下列性质的二叉树：若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉排序树。二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文件系统和数据库系统一般会采用这种数据结构进行高效率的排序与检索操作。

当前节点的左子树中的数均小于当前节点的数；
当前节点的右子树中的数均大于当前节点的数；
所有左子树和右子树自身也是二叉搜索树。

可以用中序遍历访问二叉搜索树，即按照访问左子树——根节点——右子树的方式遍历这棵树，而在访问左子树或者右子树的时候也按照同样的方式遍历，直到遍历完整棵树。遍历结束后，就得到了一个有序数组。
由于整个遍历过程具有递归的性质，我们可以直接用递归函数来模拟这一过程。
中序遍历这两棵二叉搜索树，可以得到两个有序数组。
然后可以使用双指针方法来合并这两个有序数组，这一方法将两个数组看作两个队列，每次从队列头部取出比较小的数字放到结果中（头部相同时可任取一个）。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

#define MAX_NODE_SIZE 5001

//递归：树
void inorder(struct TreeNode *node, int *res, int *pos) {
    if (node != NULL) {		//如果结点不为空
		//中序遍历：左->根->右
        inorder(node->left, res, pos);
        res[(*pos)++] = node->val;
        inorder(node->right, res, pos);
    }
}

int* getAllElements(struct TreeNode* root1, struct TreeNode* root2, int* returnSize) {
	//申请两个：表示定义一个int类型的指针变量num1，num2
    //并申请 MAX_SIZE*sizeof(int) 个字节（即4 * MAX_SIZE 个字节）的存储空间。
    int *nums1 = (int *)malloc(sizeof(int) * MAX_NODE_SIZE);
    int *nums2 = (int *)malloc(sizeof(int) * MAX_NODE_SIZE);
    int pos1 = 0, pos2 = 0;
	
	//中序遍历两个二叉搜索树
    inorder(root1, nums1, &pos1);
    inorder(root2, nums2, &pos2);

    int *merged = (int *)malloc(sizeof(int) * (pos1 + pos2));
    int p1 = 0, p2 = 0;
    int pos = 0;
    while (true) {
        if (p1 == pos1) {
            memcpy(merged + pos, nums2 + p2, sizeof(int) * (pos2 - p2));
            break;
        }
        if (p2 == pos2) {
            memcpy(merged + pos, nums1 + p1, sizeof(int) * (pos1 - p1));
            break;
        }
        if (nums1[p1] < nums2[p2]) {
            merged[pos++] = nums1[p1++];
        } else {
            merged[pos++] = nums2[p2++];
        }
    }
    *returnSize = pos1 + pos2;
    return merged;
}

您还可以看一下邱石老师的10分钟实现微信小程序支付功能课程中的新23~支付完成百分之百会调用的一个云函数小节, 巩固相关知识点