El lenguaje C se basa en el ordenamiento por fusión recursivo

Me encontré olvidándome de muchas recursiones cuando estaba escribiendo mi tarea de combinación y clasificación.

Ahora revise y resuma la recursividad de la siguiente manera:

• La clasificación por fusión utiliza la idea de dividir y conquistar. "Dividir y conquistar" significa dividir problemas complejos en simples para su solución.
• En general: Dividir y conquistar es una idea para resolver problemas complejos, y la recursividad proporciona una solución.

Déjame hablar primero de la recursividad:

1. En pocas palabras, la recursividad es llamarse a sí mismo. La relación recursiva es el establecimiento de una relación entre la propia entidad y ella misma.
2. Condiciones para la recursividad:
   (1) El subproblema debe ser consistente con el problema original y más simple.
   (2) La recursividad debe tener una salida, de lo contrario nunca saldrá.

A continuación, usamos la ordenación combinada para tener una comprensión más profunda de la recursividad:

• La idea general de la ordenación por combinación es muy simple: es decir, dividir primero y luego combinar.

Cada vez que se divide en dos, ¿cuándo terminará esta división?

Respuesta: Piénselo de esta manera, lo que finalmente queremos obtener es una matriz grande ordenada. El subproblema es obtener matrices pequeñas ordenadas. ¿Cuándo se ordenarán las matrices pequeñas? Cuando solo hay un elemento en la matriz, Luego se ordena la matriz pequeña. De esta forma, obtenemos la condición recursiva que es baja <alta.

Imagen directa arriba:

En realidad, yo también lo estaba en ese momento, y el maestro también entendió los pensamientos enseñados en clase, pero todavía no entendía cómo se fusionó y tenía una secuencia. Esto también es una crítica a mi olvido recursivo.
El código que escribí MERGE fusiona y ordena dos pequeñas matrices. (Existe el código detrás)
De hecho, es fácil entender los pasos recursivos: continúe con la imagen de arriba:

↑

Código ↓

#include <stdio.h>
#include <stdlib.h>
#define N 1000000


void Mergesort(int *A,int low,int high,int *temp)
{
    
    
    if(low < high)
    {
    
    
        int mid = (high+low)/2;
        Mergesort(A,low,mid,temp);
        Mergesort(A,mid+1,high,temp);
        MERGE(A,low,mid,high,temp);
    }
}

void MERGE(int *A,int low,int mid,int high,int *temp)
{
    
    
    int i=low;int j=mid;
    int m=mid+1;int n=high;
    int k=0;
    //开始合并两个数组；
    while(i <= j && m <= n)
    {
    
    
        if(A[i] <= A[m])
        {
    
    
            temp[k++] = A[i++];
        }
        else
        {
    
    
            temp[k++] = A[m++];
        }
    }
    while(i <= j)
    {
    
    
        temp[k++] = A[i++];
    }

    while(m <= n)
    {
    
    
        temp[k++] = A[m++];
    }

    //把temp数组中的结果装回A数组
    for(i = 0; i < k; i++)
    {
    
    
        A[i+low] = temp[i];
    }
}

int main(int argc, const char * argv[])
{
    
    
    int i,j;
    int num[100000];
    int temp[100000];
    FILE* fp = fopen("1.txt","r");//读文件
    FILE* stream = fopen("2.txt","w");//向文件中写入
    if(fp==NULL)
    {
    
    
        printf("没找到文件");
        return 0;
    }
    for(i=0;i<100000;i++)
    {
    
    
        fscanf(fp,"%d",&num[i]);
    }
    fclose(fp);
    Mergesort(num,0,99999,temp);
    for(j=0;j<100000;j++)
    {
    
    
        fprintf(stream,"%d\n",num[j]);
    }
    fclose(stream);
    return 0;
}

Hay operaciones de lectura y escritura de archivos txt en mi código, porque el trabajo necesita, (✿◡‿◡).