The first thing that I suggest is for you to get rid of those typedefs, i.e., this:
Code:
typedef struct node { double coefficient, power;
struct node *Previous, *Next;
} *equationList;
typedef equationList node;
typedef equationList resultList;
Really should just be this:
Code:
typedef struct node {
double coefficient, power;
struct node *Previous, *Next;
} node;
The reason is that when you typedef a non-opaque pointer type, you effectively hide the fact that it is a pointer type, and yet you will use objects of that type as pointers, with pointer notation. This can make it harder to reason about your program, e.g., it looks like a function returns a node object when it actually returns a pointer to a node.
You will find real world examples where pointer typedefs are used, but in such cases they are typically opaque pointers, i.e., they serve as handles to resources that you access and control purely through a library interface of functions. You usually do not directly use pointer notation with them, so while they are pointers, the fact that they are pointers is incidental to how they are used, whereas in your program the fact that they are pointers is essential to how they are used.
Related to this, I suggest that instead of using list as a parameter name, use head. The reason is that while you are dealing with a linked list, you are dealing with it through a pointer to its head node rather than through a linked list object. So it becomes clear what you mean when you write head->Next, whereas list->Next makes it sound as if you're accessing the next linked list rather than the next node after the head node of the linked list.