Сделать указатель на следующий элемент, чтобы он смог посчитать суммы в двух списках и сложил их в третий - C (СИ)

Формулировка задачи:

Здравствуйте, помогите, если чем сможет, то помогите, никак не могу правильно сделать указатель на следующий элемент, чтобы он смог посчитать суммы в двух списках и сложил их в третий. Вообще программа выглядит вот так

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct Tmultinom
{
    int step;
    int kof;
    struct Tmultinom* next;
 
}multinom;
 
void push(multinom **pfirst);
void print(multinom *pfirst);
void push2(multinom **psecond);
void print2(multinom *psecond);
void solve(multinom *pfirst, multinom *psecond, multinom *pthree);
void print3(multinom *pthree);
 
void push(multinom **pfirst)
{
    multinom *p;
    int step, kof;
    p = (multinom*)malloc(sizeof(multinom));
    p->next = *pfirst;
    *pfirst = p;
    do
    {
        printf("Enter exponent = ");
        scanf("%d", &step);
        p->step = step;
    }
    while(step < 0);
    do
    {
        printf("Enter factor = ");
        scanf("%d", &kof);
        p->kof = kof;
    }
    while(kof == 0);
    
}
 
void print(multinom *pfirst)
{
    multinom *p;
    for(p = pfirst; p != NULL; p = p->next)
    {
        if(p->next != NULL)
        {
            if(p->step == 1)
            {
                printf("%d p + ", p->kof);
            }
            else
            {
                if(p->step == 0)
                    printf("1 + ");
                else
                    printf("%d p^ %d + ", p->kof, p->step);
            }
        }
        if(p->next == NULL)
        {
            if(p->step == 1)
            {
                printf("%d p = 0\n", p->kof);
            }
            else
            {
                if(p->step == 0)
                    printf("1 = 0\n");
                else
                    printf("%d p^ %d = 0\n", p->kof, p->step);
            }
        }   
    
    }

}
void solve(multinom *pfirst, multinom *psecond, multinom **pthree)
{
    
    multinom *pf;
    multinom *ps;
    multinom *pt;
    multinom *p;
    int step, kof;
    for(pf = pfirst; pf != NULL; pf = pf->next) 
            for(ps = psecond; ps != NULL; ps = ps->next)
                if(pf->step = ps->step)
                {
                    p = (multinom*)malloc(sizeof(multinom));
                    p->next = *pthree;
                    *pthree = p;
                    (*pthree)->kof = pfirst->kof + psecond->kof;
                    
                }
                else
                {
                    printf("\nError");
                
                }

}
int _tmain(int argc, _TCHAR* argv[])
{
    multinom *pfirst = NULL;
    multinom *psecond = NULL;
    multinom *pthree = NULL;
    int i, m, j, n;
    printf("\nHow many variable = ");
        scanf("%d", &m);
 
    for(i = 0; i < m; i++)
    {
        push(&pfirst);
    }
    printf("\n");
    print(pfirst);
 
    printf("\nHow many variable = ");
    scanf("%d", &n);
    for(i = 0; i < n; i++)
    {
        push(&psecond);
    }
    printf("\n");
    print(psecond);
    solve(pfirst, psecond, &pthree);
 
    print(pthree);
    getchar();
    return 0;
}

Если кто может немного потратить время, то помогите. Ошибка заключается вот здесь в самом основном

for(pf = pfirst; pf != NULL; pf = pf->next) 
            for(ps = psecond; ps != NULL; ps = ps->next)
                if(pf->step = ps->step)
                {
                    p = (multinom*)malloc(sizeof(multinom));
                    p->next = *pthree;
                    *pthree = p;
                    (*pthree)->kof = pfirst->kof + psecond->kof;
                    
                }

У меня получается, что при выводе на экран, он мне показывает, что в новый список записалось одно и тоже число при коэффициенте.

Решение задачи: «Сделать указатель на следующий элемент, чтобы он смог посчитать суммы в двух списках и сложил их в третий»

Листинг программы

#include <stdio.h>
 
typedef struct Term {
    struct Term* next;
    int coeff;
    int exponent;
} term;
 
term* new_term(int c, int e)
{
    term* new = (term*)malloc(sizeof(term));
    new->next = NULL;
    new->coeff = c;
    new->exponent = e;
    return new;
}
 
void add_term(term** polynom, term* t)
{
    if( *polynom == NULL ) {
        *polynom = t;
    } else {
        t->next = (*polynom)->next;
        (*polynom)->next = t;
    }
}
 
term* find_term_by_exponent(term** p, int e)
{
    for( term* i = *p; i != NULL; i = i->next ) {
        if( i->exponent == e ) return i;
    }
    return NULL;
}
 
void add_polynom(term** dst, term** src)
{
    term* dst_term;
    for( term* i = *src; i != NULL; i = i->next ) {
        dst_term = find_term_by_exponent(dst, i->exponent);
        if( dst_term == NULL ) {
            add_term(dst, new_term(i->coeff, i->exponent));
        } else {
            dst_term->coeff += i->coeff;
        }
    }
}
 
term* sum_polynoms(term** p1, term** p2)
{
    term* sum = NULL;
    add_polynom(&sum, p1);
    add_polynom(&sum, p2);
    return sum;
}
 
int main(void)
{
    term* first = NULL;
    term* second = NULL;
 
    add_term(&first, new_term(1, 3));
    add_term(&first, new_term(2, 5));
 
    add_term(&second, new_term(10, 5));
    add_term(&second, new_term(3, 6));
 
    term* third = sum_polynoms(&first, &second);
 
    for( term* i = third; i != NULL; i = i->next ) {
        printf("%d * 10^%d + ", i->coeff, i->exponent);
    }
 
    return 0;
}

Объяснение кода листинга программы

Создание структуры терм для представления многочлена, включающей указатель на следующий элемент, коэффициент и показатель степени.
Создание функции для создания нового элемента многочлена.
Создание функции для добавления элемента в многочлен.
Создание функции для поиска элемента в многочлене по показателю степени.
Создание функции для добавления многочлена в многочлен.
Создание функции для сложения двух многочленов.
Создание пустого многочлена в функции main.
Добавление элементов в первый многочлен.
Добавление элементов во второй многочлен.
Вызов функции для сложения двух многочленов.
Вывод суммы многочленов в функции main.