C связана со списками функций, программа работает с ошибкой сегментации

Question

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

insertBack - поставить новый узел в конец списка

печать - распечатать текущий связанный список

Макс. - вернуть максимальное значение в списке

Min - вернуть минимальное значение в списке

locInList - вернуть номер местоположения в списке

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

Я пробовал разделять и комментировать функции, и кажется, что программа работает нормально, пока я не нажму на функцию печати. Функция печати не печатает должным образом, и я предполагаю, что ошибка сегментации возникает в моих функциях max min и locInList. Нет сообщений об ошибках от компилятора.

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

struct node
{
        int data;
        struct node *next;
};
typedef struct node node;

node* insertFront(node* head, int d);
node* insertBack(node* head, int d);
void print(node* head);
int max(node* head);
int min(node* head);
int locInList(node* head, int x);

int main()
{
        node* head = NULL;

        head = insertFront(head, 5);
        head = insertFront(head, 4);
        head = insertBack(head, 6);
        head = insertBack(head, 7);
        print(head);

        printf("Max: %d\n", max(head));
        printf("Min: %d\n", min(head));
        printf("locInList 5: %d\n", locInList(head, 5));
        printf("locInList 9: %d\n", locInList(head, 9));
   return 0;
}

node* insertFront(node* head, int d)
{
        node *tmp = NULL;
        tmp = malloc(sizeof(node));
        tmp->data = d;
        tmp->next = head;
        head = tmp;


        return head;
}

node* insertBack(node* head, int d)
{
    node *tmp = malloc(sizeof(node));

    tmp->data = d;
    tmp->next = NULL;

    if(head == NULL) return tmp;

    node *end = head;

    while(end->next != NULL){
    end = end->next;
    }
    end->next = tmp;


    return head;


}

void print(node* head)
    {

        node *tmp = head;

        while(tmp != NULL){
        printf("%d ", tmp->data);
        tmp = tmp->next;
                        }
}

int max (node* head)
{
        int max = 0;
        node *tmp = NULL;

        tmp = head;

        while(tmp->next != NULL){
                if(tmp->data >= max){
                max = tmp->data;
                tmp = tmp->next;
                           }
                           }

        return max;                             
}

int min (node* head)
{
        int min = head->data;
        node *tmp = NULL;

        tmp = head;

        while(tmp != NULL){
        if(tmp->data <= min){
                min = tmp->data;
                tmp = tmp->next;
                        }
                        } 

        return min;
}

int locInList(node* head, int x)
{

        int i = 0;
        node *tmp = NULL;

        tmp = head;

        while(tmp != NULL){


                if(tmp->data == x){
                     return i;
                }else{
                     i++;
                     tmp = tmp->next;

                        }  
                        }
                return i;

}

Answer 1

В вашем коде есть несколько ошибок, но начать с них проще:

node* insertFront(node* head, int d)
{
        node *tmp = NULL;
        tmp = malloc(sizeof(node));
        tmp->data = d;
        tmp->next = head;
        return head;   // Sure you want to return head ?
                       // The first time you call this function head is NULL
                       // and then you return NULL
                       // How about returning tmp instead
}

Теперь более сложная ошибка:

node* insertBack(node* head, int d)
{
        node *tmp = NULL;
        node *end = head;
        tmp = malloc(sizeof(node));  // Why malloc two new nodes ?
        end = malloc(sizeof(node));  // Your code shall only insert one new node
        tmp->data = d;
        tmp->next = NULL;

        while(end->next != NULL){
            end = end->next;
            end->next = tmp;  // Here you destroy the list by inserting
                              // the new node in incorrect places.
                              // You don't want to do this until
                              // the end has been reached
                      }

        return head;  // Again ... this is bad when called the first time
}

Попробуйте вместо этого:

node* insertBack(node* head, int d)
{
        node *tmp = malloc(sizeof(node));
        tmp->data = d;
        tmp->next = NULL;
        if (head == NULL) return tmp;

        node *end = head;

        while(end->next != NULL){
            end = end->next;
        }
        end->next = tmp;

        return head;
}

А в функциях max, min и locInList у вас есть ненужный tmp = malloc(sizeof(node));, который вызывает утечки памяти.

Answer 2

    node *tmp = NULL;
    tmp = malloc(sizeof(node));
    tmp = head;

Этот код сначала устанавливает tmp на NULL, затем устанавливает его так, чтобы он указывал на вновь выделенный узел, а затем устанавливает его на head. Я понятия не имею, что вы пытаетесь сделать, но последовательная установка одной и той же переменной на три разных значения не может быть правильной.

    while(tmp->next != NULL){
            if(tmp->data > max){
            max = tmp->data;
            tmp = tmp->next;
                       }
                       }

Этот код только делает tmp = tmp->next; равным tmp->data > max. Это не может быть правдой. Как только вы столкнетесь с элементом, меньшим, чем у любого предыдущего элемента, вы будете повторять внешний цикл while навсегда.

    node *tmp = NULL;
    node *end = head;
    tmp = malloc(sizeof(node));
    end = malloc(sizeof(node));

Этот код устанавливает tmp на NULL, но две строки спустя передумает и устанавливает его для указания на вновь выделенный узел. Он устанавливает end равным head, но затем двумя строками передумает и указывает на вновь выделенный узел. Зачем устанавливать какое-то значение на одно значение, чтобы сразу же установить другое? Зачем выделять два узла в функции, которая добавляет один узел в связанный список?

    while(end->next != NULL){
        end = end->next;
        end->next = tmp;
                  }

Вы хотите присоединить узел к концу списка. Но вы прикрепляете его каждый каждый раз, когда переходите от одного узла к другому!