这个单链表程序有什么问题？

Question

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

     struct node {
        int data;
    struct node* nextptr;
     } * manode;

    void add();
    void delete ();
    void display();

    int main()
    {
    int choice;

    int echoice;
    while (choice != 4) {
        printf("\n \t ENTER YOUR CHOICE FOR SINGLE LINKED LIST ");
        printf("\n \t 1. ADD ELEMENT ");
        printf("\n \t 2. DISPLAY ELEMENT ");
        printf("\n \t 3. DELETE ELEMENT ");
        printf("\n \t 4. EXIT  ");
        scanf("%d", &choice);
        switch (choice) {
        case 1:
            while (echoice != 0) {
                add();
                printf("\n DO YOU WANT TO CONTINUE 1/0 ");
                scanf("%d", &echoice);
            }
            break;
        case 2:
            display();
            break;
        case 3:
            delete ();
            break;
        case 4:
            exit(0);
            break;
        default:
            printf("\n \t WRONG VALUE ENTERED ");
        };
    }
    return 0;
}


#Add function is responsible to add the first node and all the remaining nodes as well.



    void add()
{
    struct node *tmp, *tmp2;
    tmp = malloc(sizeof(struct node));
    tmp2 = malloc(sizeof(struct node));
    int value;

    printf("    ENTER THE VALUE YOU WANT TO ENTER   ");
    scanf("%d", &value);

    if (manode == NULL) {
        manode = malloc(sizeof(struct node));
        printf("  FIRST ENTRY ");
        manode->data = value;
        manode->nextptr = NULL;
        tmp = manode;
        printf("THE DATA %d  ", manode->data);
    }


    else {
        if (tmp2 == NULL) {
            printf("\n MEMORY ALLOCATION FAILED");
        }
        else {
            tmp2->data = value;
            tmp2->nextptr = NULL;
            tmp->nextptr = tmp2;
            tmp = tmp->nextptr;
        }
    }
    //manode=tmp;
}

void display()
{
    struct node* tmp1;
    if (manode == NULL) {
        printf(" MEMORY ALLOCATION FAILED ");
    }
    else {
        tmp1 = manode;
        while (tmp1 != NULL) {
            printf("\n%d  DATA IS DISPLAY \n", tmp1->data);
            tmp1 = tmp1->nextptr;
        }
    }
}

void delete ()
{
    struct node* tmp;
    if (manode == NULL) {
        printf("NOTHING TO DELETE ");
    }
    else {
        tmp = malloc(sizeof(struct node));
    }
}

Kindly copy and compile the code, it's working but it doesn't display the contents in the list. Kindly copy and compile the code, it's working but it doesn't display the contents in the list.Kindly copy and compile the code, it's working but it doesn't display the contents in the list.Kindly copy and compile the code, it's working but it doesn't display the contents in the list.

Answer 1

As I see, there are a number of issues with your code.

• do not use conio.h . This thing is from the '80s and adds nothing to a modern program but problems
• never try to implement an ADT --- any container such as list, set, map --- as a node. It will only give you trouble: a list is a collection of nodes. Each node has a payload, some data. This data can have a key, something used to compare records. A node is not a list. A node is not the data. A list is not a node. As seen from the list, the data are the nodes. This way you can use anything as data in your list. And this is the purpose of a container: write once, use always. And the list has metadata, some obvious controls such its size, starting addres, ending address and possibly other stuff.
• do not use void() . Is a waste, sometimes an error. In your case is an error. All pointers are buried inside the functions and die there. So display() and add() does not work
• do not typedef pointers. It is a mess. In you case manode is a pointer. How are someone, even yourself a few days from now, remember what is what? If manode is a typedef for a struct everyone knows that

         manode* many_nodes[30]

declare many_nodes as a pointer to an array of structs. The asterisk tells everything: many_nodes is a pointer to manode . BTOS if you bury the * inside the typedef you will always need to refer to the code in the header.

• do not mix code of the list with I/O. It will only make your like harder. You have a list of simple int , so declare add() for instance as int add(int item, List* the_list) . This way is more readable and you can write a simple loop to fill the list with a few hundred or just one node and start testing.
• if you have a menu just write it as a function that returns the user option. But add it later to the program. A menu serves nothing to the list and to the program
• scanf() was not written to read input from the keyboard. It is for scan formatted input, hence the name. It will always give you trouble when reading from stdin. But do your part and at least always test the return of scanf(). ALWAYS. rtfm.
• do not write \n \t on a printf. Use just tabs or count the spaces.
• always initialize all variables. In your code you start testing choice and echoice with no value set.
• what is the point of having a loop on option 1, add since anyway the user will need to input an answer and enter 1 ?

Back to your program

See below your code rearranged using some of the things I wrote above. Compare with your code

Sample Code

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

typedef struct st_node
{
    int data;
    struct st_node* nextptr;

}   Node;

typedef struct tlist
{
    unsigned    size;
    Node*       start;

}   List;


int     add(int, List*);
int     delete (int, List*);
int     display(List*);
int     menu();

int         main(void)
{
    List one;
    one.size = 0;
    one.start = NULL;

    int res = menu();
    printf("menu returned %d\n", res);

    display(&one);
    for( int i = 0; i<10; i+=1)
        add(i,&one);
    display(&one);
    return 0;
}

int         add(int value, List* l)
{
    if ( l == NULL ) return -1;
    Node* node = (Node*) malloc(sizeof(Node));
    // simplest: insert at the beginning
    node->nextptr = l->start;
    node->data = value;
    l->start = node;
    l->size += 1;
    return l->size;
};

int         display(List* l)
{
    if ( l== NULL) return -1;
    if ( l->size == 0 )
    {
        printf("\n\tlist is empty\n\n");
        return 0;
    }
    else
    {
        printf("\n\t%d elements in the list\n\n", l->size);
    };

    Node* p = l->start;
    for( unsigned i = 0; i< l->size; i+=1)
    {
        printf("%3d: %11d\n", 1+i, p->data);
        p = p->nextptr;
    };
    return l->size;
}

int delete (int v, List* l)
{
    return 0;
}

int         menu()
{
    int choice = 0;
    int res = 0;
    printf(
        "\n\tENTER YOUR CHOICE FOR SINGLE LINKED LIST:\n\
\n\t\t1. ADD ELEMENT\
\n\t\t2. DISPLAY ELEMENT\
\n\t\t3. DELETE ELEMENT\
\n\t\t4. EXIT\
\n\n\t\tYour choice:   ");

   while( res != 1 )
   {
        res = scanf("%d", &choice);
        if ( choice >=1 && choice <= 4 ) return choice;
   };
   return 4;
}

OUTPUT

        ENTER YOUR CHOICE FOR SINGLE LINKED LIST:

                1. ADD ELEMENT
                2. DISPLAY ELEMENT
                3. DELETE ELEMENT
                4. EXIT

                Your choice:   2
menu returned 2

        list is empty


        10 elements in the list

  1:           9
  2:           8
  3:           7
  4:           6
  5:           5
  6:           4
  7:           3
  8:           2
  9:           1
 10:           0

And it is just an example of stuff using a more manageable list.