односвязный список

Ты своим циклом портишь head. Нужно вернуть первый элемент (голову), а ты возвращаешь предпоследний.

блин, спасибо :)

Возвращаешь предпоследний элемент нового списка вместо первого

сдал

struct Node

Node *

Это же не С.

Вот так можно:

struct Node*
Insert(struct Node *head, int data)
{
    struct Node *new_head = malloc(sizeof(struct Node));
    new_head->data = data;
    new_head->next = head;

    return new_head;
}

Или кастни qulinxao и царя, они расскажут как правильно

Царь скажет только, что связные списки не нужны.

так не проканает, там сказано, что в хвост, а не в гриву

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

А кулинхао никто не поймет.

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

Node* Insert(Node *head, int data){
    static Node *nodeend = NULL;
    Node *tmp = (Node *)malloc(sizeof(Node));
    tmp->data = data; tmp->next = NULL;
    if (head == NULL){
        head = tmp;
        return tmp;
    }
    if(nodeend)
        nodeend->next = tmp;
    nodeend = tmp;
    return tmp;
}

typedef struct buff_node{
    int data;
    struct buff_node *next, *last;
} Node;

Односвязный списки, говоришь?

Глянь с сырцы Plan9 — там это красиво реализовано.

Ну и облигаторный man queue для других любителей велосипедить.

Пример:

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

struct list {
        int item;
        struct list *next;
};

int
main()
{
        int i;
        struct list *list, **listp;

        list = NULL;
        listp = &list;

        for (i = 0; i < 10; i++) {
                *listp = calloc(1, sizeof(struct list));
                (*listp)->item = i;
                listp = &(*listp)->next;
        }

        while (list) {
                printf("%d\n", list->item);
                list = list->next;
        }

        return 0;
}

man queue

Как страшно жить.

И в чём выражается ужас?

#include <sys/queue.h>
#include <stdio.h>
#include <stdlib.h>

struct entry {
        int item;
        SIMPLEQ_ENTRY(entry) link;
} *p;

SIMPLEQ_HEAD(, entry) head;

int
main()
{
        int i;

        SIMPLEQ_INIT(&head);

        for (i = 0; i < 10; i++) {
                p = malloc(sizeof(struct entry));
                p->item = i;
                SIMPLEQ_INSERT_TAIL(&head, p, link);
        }

        SIMPLEQ_FOREACH(p, &head, link)
                printf("%d\n", p->item);

        return 0;
}

В макросах.

У тебя макрософобия? А может быть ещё и готофобия? Если вовремя не вылечить, то да — жить можеть стать страшно.

Крестофобия плиз.

Крестофобия
код на чистом C

«I am sorry, wat?» (c)

Обсуждение макросов Си переросло в обсуждение заболеваний одного из участников (это ведь ЛОР, не какой-нибудь форум IT-специалистов), я решил поддержать диалог и поделиться другими своими болячками (в придачу, к уже диагностированным), дабы выслушать мнение здешних экспертов.

К сожалению, никакого диалога не вышло. Печально, но знаете, уже даже по-домашнему.

Ты меня не совсем верно понял. Я воспринимаю «крестофобия» как неприятие кода на С++, мол, уродливый язык-мутант, не то что чистый C.

Тут кода на С++ не пробегало, так что упоминание «крестофобии» меня несколько озадачило, если не сказать больше

Зарегестрировался на hackerrank.com

Как же это круто, когда нулёвые пыхэписты-птушники учат пацанов.

Посмотрел я эту задачу - автор тотально не дружит с логикой. Почему он не метёт улицу - я не знаю.

Давай по порядку. Обход списка при вставке - это самое убогое, что аутист может придумать. Смысл списка в том и есть, что ты вставляешь в текущее место, а не головы. Обходить список при вставке будет только тот, кому положено мести улицу, а не писать код.

Т.е. ничего, кроме alloc_node() нахрен не нужно.

typedef struct node {
  struct node * next;
  int32_t data;
} node_t;

node_t * alloc_node(node_t node) {
  return memcpy(malloc(sizeof(node_t)), &node, sizeof(node_t));//маллок как аллокатор для списка - вперёд мести улицу.
}

node_t * insert(node_t * root, int32_t data) {
//   if(!root) return alloc_node((node_t){NULL, data});//что это за днищелогика? Выкинь свою макулатуру и плюнь в рожу своим "учителям"
//  while(root && root->next) root = root->next;//школьники отакуют.
  return root->next = alloc_node((node_t){NULL, data});//вот вся вставка, если у тебя это не так - метла тебя ждёт.
}

Список обходится только в обходе - всё.

Далее, убогая лапша, убожество всё. Логика сувания пустоты во вставку убога до безобразия. Создание головы всё равно выделяется на общем фоне и её унификация не имеет смысла.

/*
  Insert Node at the end of a linked list 
  head pointer input could be NULL as well for empty list
  Node is defined as 
  struct Node
  {
     int data;
     struct Node *next;
  }
*///это убожество, а не си

Node* Insert(Node *head,int data)//это не си
{//это убожество, а не код.
    Node *tmp = (Node *)malloc(sizeof(Node));//это не си.
    tmp->data = data; tmp->next = NULL;//это не си, а анскилл.
    if (head == NULL) {//это не си, а анскилл.
        head = tmp;//это не си, а анскилл.
        return tmp;//это не си, а анскилл.
    }//это убожество, а не код.
    for (; head->next != NULL; head = head->next);//это не си, а анскилл.
    head->next = tmp;//это не си, а анскилл.
    return head;//это не си, а анскилл.
}

Основная проблема кода - лапша и «знание»(если это можно так назвать) языка в районе уровня школьника. Зачем писать убогую лапшу, которая не способствует ни понимаю языка, ни даже намёка на вменяемый код?

head = tmp;

И что делает эта инструкция?

Короче, ТС запомни: аргументы это те же локальные переменные, только с предопределённым значением и не позорься больше так.

Царь скажет

Просто нули и то, что ни юзают - говно. В данном случае связный список.

потом попросит придумать для него достойную задачу

Не для не, не достойную, а РЕАЛЬНУЮ ЗАДАЧУ, в которой сможет его связный список, в данном случае.

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

Так выходит, что ни один адепт назвать применение своего высера не может. Вернее может, сославшись на кого, но аргументы за «почему это?», а не «почему не то?» нет.

Так и выходит, что всё нужно по причине «адепт не может писать код - ему надо попроще», «потому что там написано в талмуде». Так и живём, а почему меня должно волновать то, что какой-то там нуль чего не может - никто мне объяснить не может. Какое отношение священное писание нулей имеет к реальному мире - тоже.

А кулинхао никто не поймет.

Поверховная задрочка протухшей макулатуры и днищестандартов ничего не даёт. Особенно умение писать код, поэтому только кукарекать и обсираться в написании хелворда - это всё, что адепт может, т.е. умение писать код на уровне домохозяйки, либо даже ниже.

И то, кукарекать только на каком-то неведомом языке.

умение писать код

Это ты про свою низкоуровневую лапшу в десять строчек? Лол.

РЕАЛЬНУЮ ЗАДАЧУ

Да можешь сколько угодно задрачивать быдлосишку и говноапи, но реальные задачи ты никогда так и не осилишь. Потому что, во-первых, ты тупой - предметную область не поймешь, а, во-вторых, писать не умеешь - запутаешься в своей лапше, когда за свои десять строчек выйдешь. Что собственно мы и видим на практике - ни одной предложенной задачи царь так и не решил.

mov