Java 递归插入排序

我有以下问题，我有麻烦，特别是在一些部分，其中一些代码是给我的

问题描述：给定一个整数数组，返回一个数组，该数组包含使用插入排序从最大到最小排序的相同整数。我们将使用只考虑从给定索引开始并在另一个索引结束的部分数组的约定。这样，递归调用可以通过数组的任何部分工作。初始调用将传入索引0，并将索引传递给最后一个元素

插入排序（[2,1,3，-2,8]，0,4）→ [8,3,2,1，-2]
插入排序（[2,6，-4]，0,2）→ [6,2，-4]
插入排序（[2,4,6,8,10,12,14,16,18,20,22]，0,10）→ [22,20,18,16,14,12,10,8,6,4,2]

给定代码：

public int[] insertionSort(int[] nums, int begin, int end) {

}

void insert(int[] nums, int begin, int end, int element) {
  int index=end;
  while(index>=begin && nums[index]<element) {
    index--;
  }
  for(int i=end; i>index; i--) {
    nums[i+1] = nums[i];
  }
  nums[index+1] = element;
}

public int[]insertionSort（int[]nums，int-begin，int-end）{
}
无效插入（int[]nums，int开始，int结束，int元素）{
int索引=结束；
而（index>=begin&&nums[index]index；i--）{
nums[i+1]=nums[i]；
}
nums[索引+1]=元素；
}

我遇到的问题是理解“元素”变量在“插入”方法中的含义

这是我为它编写的代码

public int[] insertionSort(int[] nums, int begin, int end) {
 if(begin >= end) return nums;
 else if (begin < end){

   int element = nums.length;
   insert(nums, begin, end, element);
   insertionSort(nums, begin, end);

  }
  return nums;
}

void insert(int[] nums, int begin, int end, int element) {
  int index=end;
  while(index>=begin && nums[index]<element) {
    index--;
  }
  for(int i=end; i>index; i--) {
    nums[i+1] = nums[i];
  }
  nums[index+1] = element;
}

public int[]insertionSort（int[]nums，int-begin，int-end）{
如果（开始>=结束）返回nums；
else if（开始<结束）{
int元素=nums.length；
插入（nums、开始、结束、元素）；
insertionSort（nums、begin、end）；
}
返回nums；
}
无效插入（int[]nums，int开始，int结束，int元素）{
int索引=结束；
而（index>=begin&&nums[index]index；i--）{
nums[i+1]=nums[i]；
}
nums[索引+1]=元素；
}

以下是我从代码中得到的错误：

---

因此，您所做的错误是将元素作为nums.length传递，元素是要插入的数字，即在每次递归调用之后，它将是第（begin+1）个元素，并且您将继续将begin增加1，因为数组的该部分（0开始）已经排序。 因此下一次insertionsort将在begin+1到end调用。下面是工作示例

public class Main
{

    public static int[] insertionSort(int[] nums, int begin, int end) {
 if(begin >= end) return nums;
 else if (begin < end){

   int element = nums[begin+1];
   insert(nums, 0, begin, element);
   insertionSort(nums, begin+1, end);

  }
  return nums;
}

static void  insert(int[] nums, int begin, int end, int element) {
  int index=end;
  while(index>=begin && nums[index]<element) {
    index--;
  }
  for(int i=end; i>index; i--) {
    nums[i+1] = nums[i];
  }
  nums[index+1] = element;
}

    public static void main(String[] args) {
        int[] a = {3,41,0,10};
        int[] t = insertionSort(a, 0, 3);
        for (int i =0; i<4; i++){
            System.out.println(t[i]);
        }
    }
}

公共类主
{
公共静态int[]insertionSort（int[]nums，int begin，int end）{
如果（开始>=结束）返回nums；
else if（开始<结束）{
int元素=nums[begin+1]；
插入（nums，0，begin，element）；
插入排序（nums，开始+1，结束）；
}
返回nums；
}
静态空插入（int[]nums，int开始，int结束，int元素）{
int索引=结束；
而（index>=begin&&nums[index]index；i--）{
nums[i+1]=nums[i]；
}
nums[索引+1]=元素；
}
公共静态void main（字符串[]args）{
int[]a={3,41,0,10}；
int[]t=insertionSort（a，0，3）；
对于（inti=0；i，我认为这或多或少就是你想要做的

类递归插入排序{
公共静态void main（字符串[]args）{
int[]input1={2,1,3，-2,8}；
int[]input2={2,6，-4}；
int[]input3={2,4,6,8,10,12,14,16,18,20,22}；
int[]res1=insertionSort（input1,0,4）；
//res1=[8,3,2,1，-2]
int[]res2=insertionSort（input2，0，2）；
//res2=[6,2，-4]
int[]res3=insertionSort（input3,0,10）；
//res3=[22,20,18,16,14,12,10,8,6,4,2]
}
公共静态int[]insertionSort（int[]nums，int begin，int end）{
如果（开始>=结束）{
return nums；//我们完成了
}
//对前n-1个元素进行排序
insertionSort（nums、begin、end-1）；
//在第一个n-1元素数组中插入第n个元素
插入（nums，begin，end-1，nums[end]）；
返回nums；
}
静态空插入（int[]nums，int开始，int结束，int元素）{
int索引=结束；
while（index>=begin&&nums[index]<元素）{
索引--；
}
对于（int i=end；i>index；i--）{
nums[i+1]=nums[i]；
}
nums[索引+1]=元素；
}
}
非递归版本：

publicstatic int[]insertionSort（int[]nums，int-begin，int-end）{
对于（int i=begin+1；i=begin&&nums[index]index；i--）{
nums[i+1]=nums[i]；
}
nums[索引+1]=元素；
}
公共静态void main（字符串[]args）{
int[]is=新的int[]{5,6,7,2}；
insertionSort（is，0，is.length-1）；
System.out.println（Arrays.toString（is））；
}

递归版本：

publicstatic int[]insertionSort（int[]nums，int-begin，int-end）{
如果（开始>=结束）{
返回nums；
}
插入排序（nums、begin、end-1）；
插入（nums，begin，end-1，nums[end]）；
返回nums；
}
公共静态void插入（int[]nums，int开始，int结束，int元素）{
int索引=结束；
而（index>=begin&&nums[index]index；i--）{
nums[i+1]=nums[i]；
}
nums[索引+1]=元素；
}
公共静态void main（字符串[]args）{
int[]is=新的int[]{5,6,7,2}；
System.out.println（）；
insertionSort（is，0，is.length-1）；
System.out.println（Arrays.toString（is））；
}
下面的解决方案通过了您的所有测试用例。您的插入方法应该是这样的

public static int[] insertionSort(int[] nums, int begin, int end) {
if (begin >= end) {
    return nums;
}

for (int i = 0; i < end; i++) {
    insert(nums, i, end - 1, nums[end]);
}
return nums;

publicstatic int[]insertionSort（int[]nums，int-begin，int-end）{
如果（开始>=结束）{
返回nums；
}
for（int i=0；i

}

以下是完整的解决方案，供您快速参考

public class Solution {

public static void main(String[] args) {
    int[] input1 = { 2, 1, 3, -2, 8 };
    int[] result1 = insertionSort(input1, 0, 4);
    printArray(result1);
    int[] input2 = { 2, 6, -4 };
    int[] result2 = insertionSort(input2, 0, 2);
    printArray(result2);
    int[] input3 = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22 };
    int[] result3 = insertionSort(input3, 0, 10);
    printArray(result3);
    int[] input4 = { 6, 6, 6, };
    int[] result4 = insertionSort(input4, 0, 2);
    printArray(result4);
    int[] input5 = { 8 };
    int[] result5 = insertionSort(input5, 0, 0);
    printArray(result5);
}

public static void printArray(int[] input) {
    System.out.print("[ ");
    for (int i = 0; i < input.length; i++) {
        System.out.print(input[i] + " ");
    }
    System.out.println("]");
}

public static int[] insertionSort(int[] nums, int begin, int end) {
    if (begin >= end) {
        return nums;
    }

    for (int i = 0; i < end; i++) {
        insert(nums, i, end - 1, nums[end]);
    }
    return nums;
}

static void insert(int[] nums, int begin, int end, int element) {
    int index = end;
    while (index >= begin && nums[index] < element) {
        index--;
    }
    for (int i = end; i > index; i--) {
        nums[i + 1] = nums[i];
    }
    nums[index + 1] = element;
}

公共类解决方案{
公共静态void main（字符串[]args）{
int[]input1={2,1,3，-2,8}；
int[]result1=insertionSort（input1,0,4）；
打印阵列（result1）；
int[]input2={2,6，-4}；
int[]result2=insertionSort（input2,0,2）；
打印阵列（结果2）；
int[]input3={2,4,6,8,10,12,14,16,18,20,22}；
int[]结果