Doubling element of a double chained list

Question

I need to create a function that receives a Lita and duplicate all nodes on the list. then the list 1 2 3 4 would be 1 1 2 2 3 3 4. My attempt:

void duplicaLista (struct tDescritor *lst){
   struct tNo *p *novo;
   p = lst->ini;    
    
   while(p != NULL)
   {
      novo = malloc(sizeof(struct tNo));
      *novo = *p;
      p->prox = novo;
      p->prox = novo;
      p->prox = novo->prox;
   };
}

My structs are:

struct tAluno {
      float valor; 
      int numero; 
      char sapato[30];
};

struct tNo {
  struct tNo *ant;
  struct tAluno dado;
  struct tNo *prox;
};

struct tDescritor {
  int qtd;
  struct tNo *ini;
};

I think I’m making the first knot point to itself by making the infinite loop... but I haven’t figured out how to fix it.

Answer 1

welcome to Stackoverflow

Your problem, is that you’re making one while(p != NULL), however, you never change the variable p, so it will have an infinite loop.

novo = malloc(sizeof(struct tNo));
novo->prox = p->prox; // passa a referencia do sucessor de p para o novo, como estamos inserindo o novo após o original
p->prox = novo; // o proximo do original é o novo
novo->ant=p; // o anterior do novo, é o original
p=novo->prox; // agora p aponta para o seu sucessor antes da inclusao do novo.

If you help me, I have another example.

#include <stdio.h>
#include <stdlib.h>

struct nodo {
    struct nodo* proximo;
    struct nodo* anterior;
    int valor;
};

struct lista {
    struct nodo* cabeca;
};

void adicionar(struct lista* list, int valor) {
    printf("Adicionando o valor: \"%d\".\n", valor);
    struct nodo* no = (struct nodo*) malloc(sizeof(struct nodo));
    no->valor = valor;
    no->proximo = no->anterior = NULL;
    if(list->cabeca == NULL) {
        list->cabeca = no;
        puts("Adicionado na cabeça.");
    } else {
        struct nodo* anterior = list->cabeca->anterior;
        if(anterior == NULL) {
            list->cabeca->proximo=list->cabeca->anterior=no;
            no->anterior=list->cabeca;
        } else {
            anterior->proximo = no;
            no->anterior = anterior;
            list->cabeca->anterior=no;
        }

        puts("Adicionado no caudo.");
    }


}

void duplicar(struct lista* list){
    puts("Duplicando elementos");
    struct nodo* iterador = list->cabeca;
    while(iterador != NULL ) {

        struct nodo* tmp = (struct nodo*) malloc(sizeof(struct nodo));
        tmp->valor = iterador->valor;
        tmp->proximo = iterador->proximo;
        iterador->proximo = tmp;
        tmp->anterior=iterador;
        iterador = tmp->proximo;
    }
}

void show(struct lista* list) {

    struct nodo* iterador = list->cabeca;
    while(iterador != NULL) {

        printf("%d ", iterador->valor);
        iterador = iterador->proximo;
    }
    puts("");
}

void limpar(struct lista* list) {
    unsigned int total = 0;
    struct nodo* no = list->cabeca;
    while(no != NULL) {
        struct nodo* proximo=no->proximo;
        free(no);
        no = proximo;
        total++;
    }
    printf("Foram limpos um total de: \"%d\" referências.\n", total);
}

void main(void) {

    struct lista list;
    list.cabeca = NULL;
    for(unsigned int index=0; index<100; index++) {
        adicionar(&list, index);
    }

    show(&list);
    duplicar(&list);
    show(&list);

    limpar(&list);

}