在适当的位置添加一个节点（列表将按升序排列）

Question

我正在尝试在适当的位置添加一个节点（按升序）。 因此，当用户输入一个数字时，其值将自动存储在 memory 位置。

例如，用户输入 2,5,3,6 和 4。然后这些值将存储在 memory 位置，按升序排列，即：2,3,4,5 和 6。所以程序将打印出值。

 //ADDING A NODE INTO A LIST
printf("Enter Number:");
scanf("%d",&temp);
while(temp>=0){
    newnode = malloc(sizeof(node)); //create a memory location with the size of the node
    //whatever data size is on the node, the 'sizeof' fcn will compute its size
    newnode->value= temp;
    newnode-> next = NULL;

    if (tail==NULL){
        head=newnode;
        tail=newnode;
    } else{
        tail->next=newnode;
        tail=newnode;

    }//end if

    printf("Enter Number:"); //Repeats the process until negative number is given
    scanf("%d",&temp);
}//endwhile

然后程序将显示列表中的值

iter = head;
i=1;
while(iter!= NULL){
printf("i:%d -- value: %d\n",i, iter->value);
iter = iter-> next;
i++;

Answer 1

您走在正确的轨道上，您知道如何迭代链表和添加新节点。

现在假设用户输入了一个值val ，因此在迭代您的链表时，您必须检查当前节点的值是大于还是小于val 。 基于此，您必须在当前节点之前或之后添加val 。

Answer 2

在这里你唯一需要做的就是遍历链表，除非你找到正确的 position 来插入新节点

试着理解下面的代码，它解决了你的用例，你可以自己实现它：

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

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

void add(node**s,int num)
{
    node*temp;
    if(*s==NULL||num<(*s)->data)
    {
        temp=(node*)malloc(sizeof(node));
        temp->data=num;
        temp->next=*s;
        *s=temp;
    }
    else
    {
        temp=*s;
        while(temp!=NULL)
        {
            if(temp->data<=num&&(temp->next==NULL || temp->next->data>num))
            {
                 node*temp1=(node*)malloc(sizeof(node));
                 temp1->data=num;
                 temp1->next=temp->next;
                 temp->next=temp1;
                 return;
            }
            temp=temp->next;
        }
     }
 }

void traverse(node*s)
{
     while(s!=NULL)
     {
          printf("%d\t",s->data);
          s=s->next;
     }
}

void main()
{
     node*n=NULL;

     add(&n,2);
     add(&n,5);
     add(&n,3);
     add(&n,6);
     add(&n,4);
     traverse(n);
}

Answer 3

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

typedef struct Node {
    int value;
    struct Node * next;
} node;

int main()
{
    int i = 0;
    printf("\nEnter Number:");
    scanf("%d",&i);

    //define root node here
    node root;
    root.value = 0;
    root.next  = NULL;

    while(i>=0){

        node * newnode = (node *)malloc(sizeof(node));
        newnode->value = i;
        newnode->next  = NULL;

        node * temp = &root;
        while (1) {
            if (temp->next == NULL) {
                temp->next = newnode;
                break;
            } else {
                if (temp->next->value > newnode->value) {
                    newnode->next = temp->next;
                    temp->next = newnode;
                    break;
                } else {
                    temp = temp->next;
                }
            }
        }

        printf("\nEnter Number:"); //Repeats the process until negative number is given
        scanf("%d",&i);
    }//endwhile

    node * temp = &root;
    while (temp->next != NULL) {
        temp = temp->next;
        printf("%d,", temp->value);
    }
}

Answer 4

我将添加一个使事情变得简单的答案。 它不是最紧凑的代码，也不是性能最好的代码，但有时保持简单更重要。 当您从标准输入中读取值时，性能在这里不是问题。

但首先要注意，为这个列表设置一个tail指针是没有意义的。 当您想在列表末尾快速插入时， tail指针很好。 由于您要进行排序插入，因此无论如何都必须迭代列表，因此不会从tail指针中获得任何好处。

所以这里是简单的示例代码 - 内联注释解释了代码。

printf("Enter Number:");
scanf("%d",&temp);
while(temp>=0){
    newnode = malloc(sizeof(node));
    newnode->value= temp;
    newnode-> next = NULL;

    if (head==NULL)
    {
        // List was empty so just make newnode the head
        head=newnode;
    }
    else if (newnode->value <= head->value)
    {
        // The newnode has a value less or equal to current head
        // so the newnode can be inserted as head
        newnode->next = head;
        head = newnode;
    }
    else
    {
        // Now iterate the list to find where to insert newnode
        node* p = head;
        while(p->next)   // Repeat until end-of-list is reached
        {
            if (newnode->value <= p->next->value)
            {
                // Insert the newnode between node p and node p->next
                newnode->next = p->next;
                p->next = newnode;

                // Stop the while-loop
                break;
            } 

            // Advance to next list element
            p = p->next;
        }

        // Check if newnode was inserted or end-of-list was reached
        if (p->next == NULL)
        {
            // end-of-list was reached so insert newnode at the end
            p->next = newnode;
        }
    }

    printf("Enter Number:");
    scanf("%d",&temp);
}

一些额外的信息：

始终检查scanf返回的值 - 在这种情况下，例如：

// scanf("%d",&temp);  Dont do this but do:
if (scanf("%d",&temp) != 1)
{
    // Didn't get an int :(
    Add error handling here
}

Answer 5

做起来很简单。 写

node **current = &head;

while ( ( *current != NULL ) && !( temp < ( *current )->value ) )
{
    current = &( *current )->next;
}

newnode->next = *current;
if ( *current == NULL ) tail = newnode;
*current = newnode;

这是一个演示程序

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

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

int main(void) 
{
    node *head = NULL, *tail = NULL;

    srand( ( unsigned int )time( NULL ) );

    const size_t N = 10;

    for ( size_t i = 0; i < N; i++ )
    {
        int value = rand() % N;

        node *newnode = malloc( sizeof( node ) );
        newnode->value = value;

        node **current = &head;

        while ( ( *current != NULL ) && !( value < ( *current )->value ) )
        {
            current = &( *current )->next;
        }

        newnode->next = *current;
        if ( *current == NULL ) tail = newnode;
        *current = newnode; 
    }

    for ( node *current = head; current != NULL; current = current->next )
    {
        printf( "%d -> ", current->value );
    }

    puts( "NULL" );

    return 0;
}

程序 output 可能看起来像

1 -> 1 -> 3 -> 5 -> 5 -> 6 -> 7 -> 8 -> 9 -> 9 -> NULL

您可以将插入节点的代码移动到单独的 function 中。

例如

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

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

int insert_node( node **head, node **tail, int value )
{
    node *newnode = malloc( sizeof( node ) );

    int success = newnode != NULL;

    if ( success )
    {
        newnode->value = value;

        node **current = head;

        while ( ( *current != NULL ) && !( value < ( *current )->value ) )
        {
            current = &( *current )->next;
        }

        newnode->next = *current;
        if ( *current == NULL ) *tail = newnode;
        *current = newnode; 
    }       

    return success;
}

int main(void) 
{
    node *head = NULL, *tail = NULL;

    srand( ( unsigned int )time( NULL ) );

    const size_t N = 10;

    for ( size_t i = 0; i < N; i++ )
    {
        int value = rand() % N;
        insert_node( &head, &tail, value );     
    }

    for ( node *current = head; current != NULL; current = current->next )
    {
        printf( "%d -> ", current->value );
    }

    puts( "NULL" );

    return 0;
}

再次，程序 output 可能看起来像例如

4 -> 5 -> 6 -> 6 -> 7 -> 7 -> 8 -> 8 -> 9 -> 9 -> NULL

但是，最好再添加一个结构，例如

typedef struct list
{
    node *head;
    node *tail;
} list;

并编写处理此结构的 function insert_node 。