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

遇到的问题：
力扣108.将所有序数组转换为二叉搜索树
给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。
高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

提交后显示解答错误，
我的思路是递归以先序遍历的方式从根节点依次创建其左右节点，最后返回根节点指针。目前不知道错因

我的代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

struct TreeNode* lr(int *nums, int l, int r, struct TreeNode* rt)
{
    if(l>r)
        return NULL;
    rt=(struct TreeNode*)malloc(sizeof(struct TreeNode));
    rt->left=rt->right=NULL;
    int mid=l + (r-l)/2;
    rt->val=nums[mid];
    lr(nums,l,mid-1,rt->left);
    lr(nums,mid+1,r,rt->right);
    return rt;
}

struct TreeNode* sortedArrayToBST(int* nums, int numsSize){
    struct TreeNode *root;
    root=lr(nums,0,numsSize-1,root);
    return root;
}

执行结果：

img

这题涉及到的主要问题就是传参，应当使用二级指针作为实参传递，通过的代码如下：



/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
 
struct TreeNode* lr(int *nums, int l, int r, struct TreeNode** rt)
{
    if(l>r)
        return NULL;
    struct TreeNode* rtt=(struct TreeNode*)malloc(sizeof(struct TreeNode));
    rtt->left=rtt->right=NULL;
    int mid=l + (r-l)/2;
    rtt->val=nums[mid];
    *rt=rtt;
    lr(nums,l,mid-1,&(rtt->left));
    lr(nums,mid+1,r,&(rtt->right));
    return rtt;
}
 
struct TreeNode* sortedArrayToBST(int* nums, int numsSize){
    struct TreeNode *root;
    root=lr(nums,0,numsSize-1,&root);
    return root;
}

关于传参问题毕竟清晰易懂的解释可以参考这个https://blog.csdn.net/Kukeoo/article/details/114297192?spm=1001.2014.3001.5506

该回答引用ChatGPT
请参考下面的代码

#include<iostream>
#include<cmath>
#include<vector>

using namespace std;

bool is_prime(int n) {
  if (n <= 1) return false;
  int m = sqrt(n);
  for (int i = 2; i <= m; i++) {
    if (n % i == 0) return false;
  }
  return true;
}

int main() {
  int num_primes = 0, min_gap = 0x7fffffff, max_gap = 0, gap;
  int prime1, prime2;
  vector<int> primes;

  for (int i = 100000; num_primes < 10000; i++) {
    if (is_prime(i)) {
      num_primes++;
      primes.push_back(i);
      if (num_primes >= 2) {
        gap = primes[num_primes - 1] - primes[num_primes - 2];
        if (gap < min_gap) {
          min_gap = gap;
          prime1 = primes[num_primes - 2];
          prime2 = primes[num_primes - 1];
        }
        if (gap > max_gap) {
          max_gap = gap;
        }
      }
    }
  }

  cout << "The minimum gap is " << min_gap << " between " << prime1 << " and " << prime2 << endl;
  cout << "The maximum gap is " << max_gap << endl;

  return 0;
}