Saving a linked list

Hello, I have some doubts that I will illustrate below: Having two doubly-linked lists A and B with the structure

struct lista
    {
        Ponto* dado;        /* dado = número */
        struct lista *prox; /* ponteiro para o proximo elemento */
        struct lista *ant;  /* ponteiro para o elemento anterior */
    };

What is the difference between 1:

a->ant = b->ant;
a->prox = b->prox;
a->dado = b->dado;

and 2:

a = b;

edit 1: The reason for my doubts: I am making a code with insertionsort with linked lists. Where my error is from the line where I commented

  

/ * preparing for the next looping * /

My goal apart from this line is: First_definitive list should save the value of Smallest List when it is in the first looping, but in the second looping Smallest List is changed and I do not want the first_finite to be changed together, I want it to keep saving the value that it acquired when it entered the if until the end of code, and I can not do that. The way it is, when Minor List changes later, First_finite gets changed as well.

Lista* lista_insertionsort(Lista* l)
{

    Lista* primeiro = (Lista*)malloc(sizeof(Lista));
    Lista* menor = (Lista*)malloc(sizeof(Lista));
    Lista* p = (Lista*)malloc(sizeof(Lista));
    Lista* primeiro_definitivo = (Lista*)malloc(sizeof(Lista));
    primeiro_definitivo = l;
    primeiro = l;
    menor = l;
    p = l;
    int alterado = 0;



    while(menor->prox != NULL)
    {
        printf("oi2\n");
        //Encontra o menor
        while(p != NULL)
        {
            if(menor->dado->x > p->dado->x)
                menor = p;
            p=p->prox;
        }
        printf("menor dado: %d", menor->dado->x);
        /*
        Nesta parte do código: menor aponta para o menor valor
        p aponta para o ultimo elemento da lista
        primeiro aponta para o primeiro que não foi alterado
        */
        //troca de posição primeiro com menor
        if(primeiro->dado->x != menor->dado->x)
        {

            if(primeiro->prox->dado->x == menor->dado->x)
                troca_adjacentes(primeiro, menor);

            else
                troca_nao_adjacentes(primeiro, menor);

            alterado = 1;
        }

        /* preparando para o proximo looping */
        if(alterado == 1){
            p = menor;
            p->ant = menor->ant;
            p->prox = menor->prox;
            p->dado = menor->dado;
            primeiro = menor->prox;
            if(menor->ant == NULL){//caso seja o menor da lista inteira, ele será o retorno

                primeiro_definitivo = menor;
                }
        }
        else{
        p = menor;
        primeiro = primeiro->prox;
        p->ant = primeiro->ant;
        p->prox = primeiro->prox;
        p->dado = primeiro->dado;
        }
        alterado = 0;
    }
    return primeiro_definitivo;

}