Swapping elements in a linked list - c

Question

So I'm running into a little problem with my sorting function.
While it's doing what it's supposed to in the second edge case,
the elements get swapped and then swapped back continuously.
The example here happens when Sven(25) and Bob(22) meet.
void sortPerson(person *pers, person* newPerson)
{
if(pers == NULL || pers->next == NULL)
{
printf("List is emtpy");
return;
}
person* tempValue;
person* prev = pers;
person* curr = pers->next;
//person* newValue = pers;
while(prev != NULL && curr != NULL)
{
//first edge case
//adds a new person
if(prev->age < newPerson->age)
{
newPerson->next = prev->next;
prev->next = newPerson;
}
//second edge case
//swapping process when prev age greater than curr age
//forming a decending order of ages
if(prev->age > curr->age)
{
tempValue = prev;
prev = prev->next;
prev->next = tempValue;
printf("\nPerson age: %d\n", tempValue->age);
printf("loop test\n");
printf("%d and %d\n",prev->age, prev->next->age);
}
//third edge case
//if age is the same do nothing
if(prev->age == curr->age)
{
return;
}
prev = prev->next;
curr = curr->next;
}
}
This function returns a new person
person* addPerson( person *newPers ){
return newPers;
}
And here is my main if you want to test it yourself
int main(){
person* person1 = construct_person("Max", 20);
person* person2 = construct_person("Sven", 25);
person* person3 = construct_person("Bob", 22);
person* person4 = construct_person("John", 23);
person* newPerson = construct_person("Markus", 21);
person1->next = person2;
person2->next = person3;
person3->next = person4;
//person4->next = addPerson(person1, newPerson);
//swapPerson(person1);
sortPerson(person1, addPerson(newPerson));
printperson(person1);
free(person1);
free(person2);
free(person3);
free(person4);
free(newPerson);
}
My struct person and constructor
typedef struct person person;
struct person{
char *name;
int age;
person *next;
};
person* construct_person(char *name, int age)
{
person* pers = (person*) malloc (sizeof(person));
pers->name = name;
pers->age = age;
pers->next = NULL;
return pers;
}
I suspect the problem is that my 'prev' struct pointer gets altered throughout the process, but I'd like a second opinion and potential fix.
*Note I'm only freeing it like this because this is testing only and I'm not gonna add more people else I'd done so iteratively.

Answer 1

Some remarks:
The name sortPerson is not well chosen. It should better be named insertPerson
You cannot hope to sort a list with just one iteration and a swap here and there during that iteration. If that were possible, you would have invented the most efficient sorting algorithm. So, this cannot work -- at least not always.
Instead of implementing some sort algorithm (like bubble sort, selection sort, ...), make sure you add all persons using that insertPerson function. That way you can be sure that the list into which a new person is inserted, is already sorted. This way you don't have to swap elements at all. You only have to find the correct insertion point and insert the new person there. So in the main program you should not be fiddling with next pointers. Leave that to this insertPerson function.
When a list is empty or just has one person, you should still insert the new person. It makes no sense to not do it when the list is empty (or just has one element).
The only base case is when you need to insert the person before all other persons. In that case the reference to the first person needs to change, as the new person becomes that first person. One way to make that work, is to make the first parameter a call-by-reference. In other words: pass the address of where the first person pointer is stored, so that this pointer can be changed, and the caller will have access to that change.
I don't see the logic in omitting an insertion when the age of the new person matches the age of a person already in the list. Surely your list should allow Bob and Alice, even when they are both 28.
There are several other points to make...
Here is a working version. I had to make some assumptions about the code that you didn't share, but the principle should be clear even if your code is different:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct person_s {
int age;
char name[100];
struct person_s * next;
} person;
person* construct_person(char* name, int age) {
person* p = malloc(sizeof(person));
strcpy(p->name, name);
p->age = age;
p->next = NULL;
return p;
};
void insertPerson(person** youngest, char* name, int age)
{
person* newPerson = construct_person(name, age);
// Even when list is empty, still add it
if (*youngest == NULL || (*youngest)->age > age) {
newPerson->next = *youngest;
*youngest = newPerson;
return;
}
person* prev = *youngest;
person* curr = prev->next;
// Search insertion point
while (curr != NULL && curr->age < age) {
prev = curr;
curr = curr->next;
}
// Found it:
prev->next = newPerson;
newPerson->next = curr;
}
void printList(person* pers) {
while (pers != NULL) {
printf("%s is %d years old.\n", pers->name, pers->age);
pers = pers->next;
}
}
void freeList(person** pers) {
while (*pers != NULL) {
person* temp = *pers;
*pers = (*pers)->next;
free(temp);
}
}
int main(){
person* personList = NULL;
insertPerson(&personList, "Max", 20);
insertPerson(&personList, "Sven", 25);
insertPerson(&personList, "Bob", 22);
insertPerson(&personList, "John", 23);
insertPerson(&personList, "Markus", 21);
printList(personList);
freeList(&personList);
}