변환 Java 방법으로 재귀적 방법?(삽입 정렬)

Question

려고 노력해요 이해하는 방법과 재귀하여 현재 반복적인 삽입 정렬로 재귀 하나입니다.

나는 무엇을 할 필요가 나의 코드들을 재귀?

• 나는 생각한 경우도록 되지 않는 무한 루프입니다.
• 나는 확실하지 않다 나는 완전히 이해 재귀.어쩌면 당신은 그것을 만들 수 있습니 나에게 명확?
• 나의 많은 일을 읽지만 나는 아직도 알 수 없는 곳을 시작합니다.

여기에는 나의 코드:

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;
        }
    }
}

Answer 1

변환 외부를 위한 루프의 종류 간단하다.을 극복하는 동안 당신이 필요 재귀 도우미 기능입니다.당신이 함수를 호출해야에서 주로 insertion_srt(array, 0, array.length):

public static void insertion_srt(int array[], int beg_index, int n) {
    if(beg_index >= n-1)
            return;
    int i = beg_index + 1;
    int j = i;
    int B = array[i];
    j=helper(array, j, B);
    array[j] = B;
    insertion_srt(array, beg_index + 1, n);
}

private static int helper(int[] array, int j, int B) {
    if(j <= 0 || array[j-1] <= B)
        return j;
    array[j] = array[j - 1];
    return helper(array, j-1, B);
}

Answer 2

이것은 개인적으로 좋아하는 훌륭한 접근법입니다.그것은 세 가지 방법을 사용하지만 이해하기가 매우 간단합니다.루프 용 루프 및 삽입 insertin을 루프에 대한 내부 중첩으로 생각하는 삽입

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
    }
}

.

Answer 3

재귀가 작동하는 방식을 이해하는 좋은 방법은 나누기 및 정복 알고리즘의 개념을 이해하는 것입니다.이 기술은 모든 종류의 문제에 대한 효율적인 알고리즘의 기초입니다.

뒤에있는 아이디어는 문제를 더 작은 서브 프로 럼으로 나누는 것입니다.

• 는 2 (또는 그 이상) 서브 프로바스로 나눕니다.
• 각 하위 프로바스를 재귀 적으로 해결하십시오.
• 결과를 결합하십시오.

삽입 정렬은 분할 및 정복 알고리즘의 가장 좋은 예가 아니지만이 방법으로 접근 할 수 있습니다.문제를 2 개의 서브 프로바스로 나눌 수 있습니다.

• last 요소
• 모든 것

이 방법으로 소위 꼬리 재귀를 얻을 수 있습니다.모든 루프는 꼬리 재귀로 변환하기가 상대적으로 쉽습니다.

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);
    }
}

.

Answer 4

이 간단한 재귀 적 접근 방식을 시도해보십시오.

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

    insertionSort(array, index + 1);

    // insert array[index] into the array

}

.