Thread: Copying a linked list into another linked list

Hi,
I want to write a copy_list function that creates a linked list(the function result) with new nodes that contain the same data as the linked list referenced by the single argument of copy_list
My structures:

Code:

typedef struct name_node_s {
  char name[11];
  struct name_node_s *restp;
}name_node_t;
typedef struct {
  name_node_t *headp;
  int size;
}name_list_t;

Copy_list function:

Code:

name_node_t *copy_list(name_node_t *head){
	name_node_t *current = head;
	name_node_t *newList = NULL;
	name_node_t *tail = NULL;
	
	while (current != NULL){
		if (newList == NULL) {
			newList = malloc(sizeof(name_node_t));
			strcpy(newList->name, current->name);
			newList->restp = NULL;
			tail = newList;
		}
		else {
			tail->restp = malloc(sizeof(name_node_t));
			tail = tail->restp;
			strcpy(tail->name, current->name);
			tail->restp = NULL;
		}
		current = current->restp;
	}
	return(newList);
}

And rest of code:

Code:

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

typedef struct name_node_s {
  char name[11];
  struct name_node_s *restp;
}name_node_t;
typedef struct {
  name_node_t *headp;
  int size;
}name_list_t;
name_node_t* presidents(void);
void insertAfter(name_node_t* mynode,name_node_t* newNode);
//void delete_last(name_node_t** headRef);
//void ListDelete(name_list_t* listP, char pname[]);
void lastDelete(name_list_t* listP);
void place_first(name_node_t **headRef, char pname[]);
name_node_t *copy_list(name_node_t *head);
int main(void)
{
  name_list_t list;
  name_list_t list_two;
  //name_node_t *np, *qp;
  list.headp = presidents();
  name_node_t *new_node;
  new_node = malloc(sizeof(name_node_t));
  strcpy(new_node->name, "Eisenhower");
  insertAfter(list.headp->restp, new_node);
  lastDelete(&list);
  place_first(&list.headp, "Mustafa");
  printf("%s %s %s %s", list.headp->name, list.headp->restp->name, list.headp->restp->restp->name, list.headp->restp->restp->restp->name);
  list_two.headp = copy_list(list.headp);
  printf("%s %s %s %s", list_two.headp->name, list.headp->restp->name, list.headp->restp->restp->name, list.headp->restp->restp->restp->name);

  return(0);
}
name_node_t* presidents(void)
{
  name_node_t* head = NULL;
  name_node_t* second = NULL;
  name_node_t* third = NULL;
  
  head = malloc(sizeof(name_node_t));
  second = malloc(sizeof(name_node_t));
  third = malloc (sizeof(name_node_t));

  strcpy(head->name, "Washington");
  head->restp = second;
    
  strcpy(second->name, "Roosevelt");
  second->restp = third;

  strcpy(third->name, "Kennedy");
  third->restp = NULL;

  return(head);
}
void insertAfter(name_node_t* mynode,name_node_t* newNode)
{
	newNode->restp = mynode->restp;
	mynode->restp = newNode;
}

void ListDelete(name_list_t* listP, char pname[]){
	name_node_t *to_freep, *cur_nodep;
	if(strcmp(listP->headp->name, pname)){
		to_freep = listP->headp;
		listP->headp = to_freep->restp;
		--(listP->size);
	}
	else {
		for (cur_nodep = listP->headp;
			cur_nodep->restp != NULL && !strcmp(cur_nodep->restp->name, pname);
			cur_nodep = cur_nodep->restp) {
				if( cur_nodep->restp != NULL && strcmp(cur_nodep->restp->name, pname)) {
					to_freep = cur_nodep->restp;
					cur_nodep->restp = to_freep->restp;
					free(to_freep);
					--(listP->size);
				}
			}
		}
	}
void lastDelete(name_list_t* listP){
	name_node_t *to_freep, *cur_nodep;
	for (cur_nodep = listP->headp;
			cur_nodep->restp != NULL;
			cur_nodep = cur_nodep->restp) {}
	to_freep = cur_nodep;
	cur_nodep->restp = to_freep->restp;
	free(to_freep);
	--(listP->size);
}
void place_first(name_node_t **headRef, char pname[]) {
	name_node_t *newNode = malloc(sizeof(name_node_t));
	strcpy(newNode->name, pname);
	newNode->restp = *headRef;
	*headRef = newNode;
}
/*name_node_t *copy_list(name_node_t *head) {
	name_node_t *current = head;
	name_node_t *newList = NULL;
	name_node_t **lastPtr;
	
	lastPtr = &newList;
	
	while (current != NULL) {
		printf("**");
		place_first(lastPtr, current->name);
		lastPtr = &((*lastPtr)->restp);
		current = current->restp;
	}
	return(newList);
}*/
/*name_node_t *copy_list(name_node_t *head) {
	if (head == NULL)
		return NULL;
	else {
		name_node_t *newList = malloc(sizeof(name_list_t));
		strcpy(newList->name, head->name);
		newList->restp = copy_list(head->restp);
		
		return(newList);
	}
}*/
name_node_t *copy_list(name_node_t *head){
	name_node_t *current = head;
	name_node_t *newList = NULL;
	name_node_t *tail = NULL;
	
	while (current != NULL){
		if (newList == NULL) {
			newList = malloc(sizeof(name_node_t));
			strcpy(newList->name, current->name);
			newList->restp = NULL;
			tail = newList;
		}
		else {
			tail->restp = malloc(sizeof(name_node_t));
			tail = tail->restp;
			strcpy(tail->name, current->name);
			tail->restp = NULL;
		}
		current = current->restp;
	}
	return(newList);
}

What did you want to actually ask?

My function(copy_list) doesn't work.I can't figure out where is the problem.

Oh sure! Now Andrew wants the problem to actually be described for him!

So spoiled! < LOL >

Originally Posted by AndrewHunter

LOL..... I know I am such a prima donna!

Heck man... we already knew that...