将Java方法转换为递归方法？（插入排序）

我试图理解递归，以及如何将当前迭代的插入排序转换为递归排序

我需要对代码做什么才能使其递归

• 我想我需要一个基本情况，这样它就不会变成一个无限循环
• 我不确定我是否完全理解递归。也许你能让我更清楚一点
• 我读了很多书，但还是不知道从哪里开始

这是我的密码：

public class InsertionSort
{

    public static void main(String a[])
    {

        int i;
        int array[] =
        { 8, 33, 12, 99, 0, 17 };

        System.out.println("Values of Array before the sort: ");

        for (i = 0; i < array.length; i++)
        {
            System.out.print(array[i] + "  ");
        }

        insertion_srt(array, array.length);

        System.out.println("");
        System.out.println("Values of Array after the sort: ");

        for (i = 0; i < array.length; i++)
        {
            System.out.print(array[i] + "  ");
        }

    }

    public static void insertion_srt(int array[], int n)
    {

        for (int i = 1; i < n; i++)
        {

            int j = i;
            int B = array[i];

            while ((j > 0) && (array[j - 1] > B))
            {
                array[j] = array[j - 1];
                j--;
            }

            array[j] = B;
        }
    }
}

公共类插入排序
{
公共静态void main（字符串a[]
{
int i；
整数数组[]=
{ 8, 33, 12, 99, 0, 17 };
System.out.println（“排序之前的数组值：”）；
对于（i=0；i0）&（数组[j-1]>B））
{
数组[j]=数组[j-1]；
j--；
}
数组[j]=B；
}
}
}

理解递归工作原理的一个好方法是理解分治算法的概念。这项技术是解决各种问题的有效算法的基础

其背后的思想是将问题划分为更小的子问题，所有子问题都可以用相同的方式解决：

• 分为2个（或更多）子问题
• 递归地解决每个子问题
• 结合结果

插入排序不是分治算法的最佳示例，但仍然可以通过这种方式进行。您可以将问题分为两个子问题：

• 最后元素
• 其他一切

这样，您将获得所谓的尾部递归。所有循环都相对容易转换为尾部递归

public static void insertion_srt(int array[], int n, int j) {
    if (j < n) {
        int i;
        int temp = array[j];

        for (i=j; i > 0 && array[i-1] > temp; i--) array[i] = array[i-1];
        array[i] = temp;

        insertion_srt(array,n, j+1);
    }
}

公共静态空插入\u srt（int数组[]，int n，int j）{
if（j0&&array[i-1]>temp；i--）array[i]=array[i-1]；
数组[i]=温度；
插入srt（数组，n，j+1）；
}
}

试试这个简单的递归方法：

public static void insertionSort(int[] array, int index) {
    if(array.length == index + 1) return;

    insertionSort(array, index + 1);

    // insert array[index] into the array

}

---

转换外部for循环有点琐碎。要克服while循环，需要一个小的递归助手函数。您必须在main中调用函数作为插入（array，0，array.length）：

publicstaticvoidinsertion\u srt（int数组[]，int beg\u索引，int n）{
如果（beg_索引>=n-1）
返回；
int i=beg_指数+1；
int j=i；
int B=数组[i]；
j=助手（数组，j，B）；
数组[j]=B；
插入srt（数组，beg_索引+1，n）；
}
私有静态int-helper（int[]数组，int j，int B）{
if（j这是我个人喜欢的好方法。它确实使用了三种方法，但它们很容易理解。将insertionOut看作外部for循环，将insertionIn看作内部嵌套for循环

public static void insertionRecursive(int[] a){
    if(a.length > 0){ // base case
        insertionOut(a, 1, a.length);
    }
}   
private static void insertionOut(int[] a, int i, int length){ //outer loop
    if(i < length){ // iterates from 1 to the length
        int temp = a[i]; // temp value
        int k = i;
        insertionIn(a, k, temp);
        insertionOut(a, i + 1, length); // iterates through the loop
    }
}
private static void insertionIn(int[] a, int k, int temp){ // inner loop
    if(k > 0 && a[k - 1] > temp){
       //this does a basic swap
        a[k] = temp;
        a[k] = a[k - 1];
        a[k - 1] = temp;
        insertionIn(a, k - 1, temp);    // iterates through the loop
    }
}

publicstaticvoidinsertionrecursive（int[]a）{
如果（a.length>0）{//基本情况
插入输出（a，1，a.长度）；
}
}   
私有静态void insertionOut（int[]a，int-i，int-length）{//outer循环
如果（i0&&a[k-1]>temp）{
//这是一个基本的交换
a[k]=温度；
a[k]=a[k-1]；
a[k-1]=温度；
insertionIn（a，k-1，temp）；//遍历循环
}
}
我建议您在答案中添加更多信息。到目前为止，这并没有太大帮助，但这是一个很好的开始。请记住，尽管递归解决方案通常比交互式解决方案更优雅，但java并不适合递归，因为它没有尾部调用优化。这是编译器转换递归函数的能力将调用转换为迭代形式，从而防止调用堆栈被破坏。因此，在java中，具有任意深度的递归最终将导致内存不足异常。您是否阅读了本文并了解了所有内容？我将如何使用上面的代码实现这一点？可能太简单了，我只是不理解它：/
public static void insertionRecursive(int[] a){
    if(a.length > 0){ // base case
        insertionOut(a, 1, a.length);
    }
}   
private static void insertionOut(int[] a, int i, int length){ //outer loop
    if(i < length){ // iterates from 1 to the length
        int temp = a[i]; // temp value
        int k = i;
        insertionIn(a, k, temp);
        insertionOut(a, i + 1, length); // iterates through the loop
    }
}
private static void insertionIn(int[] a, int k, int temp){ // inner loop
    if(k > 0 && a[k - 1] > temp){
       //this does a basic swap
        a[k] = temp;
        a[k] = a[k - 1];
        a[k - 1] = temp;
        insertionIn(a, k - 1, temp);    // iterates through the loop
    }
}