Как я могу получить нечетные индексированные узлы связанного списка в другом связанном списке? Я не хочу использовать двойной указатель - PullRequest
Новая
       20

Как я могу получить нечетные индексированные узлы связанного списка в другом связанном списке? Я не хочу использовать двойной указатель

0 голосов
/ 11 февраля 2020

Я не хочу использовать двойной указатель в моем коде, пожалуйста, примите индекс первого узла равным 1. У меня есть связанный список 10-> 20-> 30-> 40-> 50-> 60-> 70- > 80-> 90-> 100-> NULL В другом связанном списке, указателем заголовка которого является pLink, я хочу скопировать нечетные индексированные узлы и получить вывод в виде 10-> 30-> 50-> 70-> 90-> NULL. 

    SLLI*OddNodes(SLLI*pHead)
{
    int counter =1;
    SLLI*pTemp=pHead;
    SLLI*pList=NULL;
    while(pTemp != NULL)
    {
        if(counter % 2 != 0)
        {
           if(pList==NULL)
           {
               pList=malloc(sizeof(SLLI));
               pList->data=pTemp->data;
               pList->next=NULL;
           }
           else
           {
               SLLI*pIter=pList;
               SLLI*pNew=malloc(sizeof(SLLI));
               pNew->data=pTemp->data;
               pNew->next=NULL;
               pIter->next=pNew;
               pIter=pIter->next;

           }
        }
        pTemp=pTemp->next;
        counter ++;
    }
    return pList;
}

Когда я запускаю этот код, я получаю вывод как 10-> 90-> NULL. Я знаю, что у меня проблема с частью "else". SLLI * pIter = pList не имеет никакого смысла, но что я могу сделать для устранения этой ошибки?

Ответы [ 3 ]

1 голос
/ 11 февраля 2020

Полагаю, проблема в том, что pList совсем не изменилось в вашем else утверждении.

Разве это не помогло бы: 

SLLI*OddNodes(SLLI*pHead)
{
   int counter =1;
   SLLI*pTemp=pHead;
   SLLI*pList=NULL;
   SLLI*pNewHead=NULL;

   while(pTemp != NULL)
   {
      if(counter % 2 != 0)
      {
         if(pList==NULL)
         {
            pList=malloc(sizeof(SLLI));
            pList->data=pTemp->data;
            pList->next=NULL;
            pNewHead = pList;
         }
         else
         {
            pList->next = malloc(sizeof(SLLI));
            pList->next->data = pTemp->data;
            pList->next->next = NULL;
            pList = pList->next;
         } 
         pTemp = pTemp->next;
         counter++
      }
   }

   return pNewHead;
}

Кроме того, я бы проверил если malloc было успешным

0 голосов
/ 11 февраля 2020

Просто DRY дополнение к Влад из Москвы ответ : 

/**
 * Returns a list with the data from every other item starting at *original.
 * Does not modify the nodes from *original: malloc()s new nodes
 */
SLLI *OddNodes(SLLI const *original)
{
    int odd = 0;
    SLLI oddHead = { 0, NULL },
        *copy = &oddHead;

    for ( ; original != NULL ; original = original->next)
        if (odd ^= 1) {
            if (NULL == (copy->next = malloc(sizeof *copy)))
            /* alternatively, free "oddHead.next" & return NULL.
             * Should be documented in head comment! */
                exit(EXIT_FAILURE);
            copy = copy->next;
            copy->data = original->data;
            copy->next = NULL;
        }

    return oddHead.next;
}
0 голосов
/ 11 февраля 2020

Вот, пожалуйста. 

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

typedef struct SinglyLinkedListItem
{
    int data;
    struct SinglyLinkedListItem *next;
} SLLI;

SLLI * OddNodes( SLLI *pHead )
{
    int odd = 0;
    SLLI *pList = NULL;


    for ( SLLI *pCurrent = pList; pHead != NULL; pHead = pHead->next )
    {
        if ( odd ^= 1 )
        {
            if ( pCurrent == NULL )
            {
                pList = malloc( sizeof( SLLI ) );
                pList->data = pHead->data;
                pList->next = NULL;
                pCurrent = pList;
            }
            else
            {
                pCurrent->next = malloc( sizeof( SLLI ) );
                pCurrent->next->data = pHead->data;
                pCurrent->next->next = NULL;
                pCurrent = pCurrent->next;
            }
        }
    }

    return pList;
}
 int insert( SLLI **pHead, int data )
 {
    SLLI *pCurrent = malloc( sizeof( SLLI ) );
    int success = pCurrent != NULL;

    if ( success )
    {
        pCurrent->data = data;
        pCurrent->next = *pHead;
        *pHead = pCurrent;
    }

    return success;
 }

 void out( SLLI *pHead )
 {
    for ( ; pHead != NULL; pHead = pHead->next )
    {
        printf( "%d -> ", pHead->data );
    }

    puts( "null" );
 }

int main(void) 
{
    const int N = 10;

    SLLI *pHead = NULL;

    for ( int i = N; i != 0; --i )
    {
        insert( &pHead, 10 * i );
    }

    out( pHead );

    SLLI *pSecondHead = OddNodes( pHead );

    out( pHead );
    out( pSecondHead );

    return 0;
}

Вывод программы: 

10 -> 20 -> 30 -> 40 -> 50 -> 60 -> 70 -> 80 -> 90 -> 100 -> null
10 -> 20 -> 30 -> 40 -> 50 -> 60 -> 70 -> 80 -> 90 -> 100 -> null
10 -> 30 -> 50 -> 70 -> 90 -> null
...