通过插入新元素的链表C编程错误 [英] linked list c programming error by inserting new element

问题描述

我正在尝试插入一个元素，但它收到错误消息进程以退出代码11完成"

I am trying to insert an element but it get the error "Process finished with exit code 11"

struct node {
    int key;
    struct node *next;
};
struct node* init(){
    struct node *head =NULL;
    return head;
}
void create(struct node * head,int num) {
    struct node * tmp = head;
    struct node * prev = NULL;
    struct node* new = malloc(sizeof(struct node));
    new->key = num;
    prev = tmp;
    tmp = tmp->next;
    while(tmp!= NULL && tmp->key < num){
        prev = tmp;
        tmp = tmp->next;
    }
    new->next = tmp;
    prev->next = new;
    if (tmp== NULL)
        head=tmp;
    }
int main() {
    int num;
    struct node* head;
    head=init()
    printf("Enter data:");
    scanf("%d",&num);
    create(head,num);
}

我正在尝试将元素插入到链表中，并且应该同时对元素进行排序和输入.有人可以告诉我错误是吗?我似乎无法找出错误.

i am trying to insert an element into a linked list and the element should be sorted and entered at the same time.can someone tell me that the error is ? i cannot seem to find out the error.

推荐答案

目前尚不清楚您的函数create()

It's not clear what your function create()

void create(struct node * head, int num) {
  struct node * tmp = head;
  struct node * prev = NULL;
  struct node* new = malloc(sizeof(struct node));
  new->key = num;
  prev = tmp;
  tmp = tmp->next;
  while (tmp != NULL && tmp->key < num) {
      prev = tmp;
      tmp = tmp->next;
  }
  new->next = tmp;
  prev->next = new;
  if (tmp == NULL)
      head = tmp;
}

应该会做.您可以有效地将其传递给NULL指针并返回void，因此它所做的一切对外界都是毫无意义的.

is supposed to do. You effectively pass it a NULL pointer and return void, so everything it does is meaningless to the outside world.

每个no bs链表实现的 ^tm 起点:

The^tm starting point for every no bs linked list implementation:

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

typedef struct node_tag {
    int value;
    struct node_tag *next;
} node_t;

// write functions to encapsulate the data and provide a stable interface:

node_t* node_create_value(int value)
{
    node_t *new_node = calloc(1, sizeof *new_node);
    if(new_node) new_node->value = value;
    return new_node;
}

node_t* node_advance(node_t const *node) { return node->next; }


typedef struct list_tag {  // a list usually consists of
    node_t *head;          // a pointer to the first and
    node_t *tail;          // a pointer to the last element
    // size_t size;        // one might want to add that.
} list_t;

list_t list_create(void)
{
    list_t list = { NULL, NULL };
    return list;
}

// make code based on these functions "speak" for itself:

node_t* list_begin(list_t const *list) { return list->head; }
node_t* list_end  (list_t const *list) { return list->tail; }
bool list_is_empty(list_t const *list) { return !list_begin(list); }

// common operations for lists:

node_t* list_push_front(list_t *list, int value)
{
    node_t *new_node = node_create_value(value);
    if (!new_node)
        return NULL;

    new_node->next = list->head;
    return list->head = new_node;
}

node_t* list_push_back(list_t *list, int value)
{
    // push_back on an empty list is push_front:
    if (list_is_empty(list))
        return list->tail = list_push_front(list, value);

    node_t *new_node = node_create_value(value);
    if (!new_node)
        return NULL;

    list->tail->next = new_node;
    return list->tail = new_node;
}

node_t* list_insert_after(list_t *list, node_t *node, int value)
{
    if (list_end(list) == node)
        return list_push_back(list, value);

    node_t *new_node = node_create_value(value);
    if (!new_node)
        return NULL;

    new_node->next = node->next;
    return node->next = new_node;
}

node_t* list_insert_sorted(list_t *list, int value)
{
    // first handle the special cases that don't require iterating the whole list:

    if (list_is_empty(list) || value < list_begin(list)->value)
        return list_push_front(list, value);

    if (value > list_end(list)->value)
        return list_push_back(list, value);

    // the general (worst) case:

    for (node_t *current_node = list_begin(list); node_advance(current_node); current_node = node_advance(current_node))
        if (value < node_advance(current_node)->value)
            return list_insert_after(list, current_node, value);

    return NULL; // should never happen
}

void list_print(list_t const *list)
{
    for (node_t *current_node = list_begin(list); current_node; current_node = node_advance(current_node))
        printf("%d\n", current_node->value);
}

void list_free(list_t *list)
{
    for(node_t *current_node = list_begin(list), *next_node; current_node; current_node = next_node) {
        next_node = current_node->next;
        free(current_node);
    }
}

// user code should not be required to know anything about the inner workings
// of our list:

int main(void)
{
    list_t list = list_create();
    for (int i = 1; i < 10; i += 2) {
        if (!list_push_back(&list, i)) {
            list_free(&list);
            fputs("Not enough memory :(\n\n", stderr);
            return EXIT_FAILURE;
        }
    }

    list_print(&list);
    putchar('\n');

    for (int i = 0; i < 11; i += 2) {
        if (!list_insert_sorted(&list, i)) {
            list_free(&list);
            fputs("Not enough memory :(\n\n", stderr);
            return EXIT_FAILURE;
        }
    }

    list_print(&list);
    list_free(&list);
}

输出:

1
3
5
7
9

0
1
2
3
4
5
6
7
8
9
10

这篇关于通过插入新元素的链表C编程错误的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！